+
−/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+
− * vim: sw=2 ts=8 et :
+
− */
+
−/* This Source Code Form is subject to the terms of the Mozilla Public
+
− * License, v. 2.0. If a copy of the MPL was not distributed with this
+
− * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
−
+
−#include "Layers.h"
+
−#include <algorithm>                    // for max, min
+
−#include "apz/src/AsyncPanZoomController.h"
+
−#include "CompositableHost.h"           // for CompositableHost
+
−#include "ImageContainer.h"             // for ImageContainer, etc
+
−#include "ImageLayers.h"                // for ImageLayer
+
−#include "LayerSorter.h"                // for SortLayersBy3DZOrder
+
−#include "LayersLogging.h"              // for AppendToString
+
−#include "LayerUserData.h"
+
−#include "ReadbackLayer.h"              // for ReadbackLayer
+
−#include "UnitTransforms.h"             // for ViewAs
+
−#include "gfxEnv.h"
+
−#include "gfxPlatform.h"                // for gfxPlatform
+
−#include "gfxPrefs.h"
+
−#include "gfxUtils.h"                   // for gfxUtils, etc
+
−#include "gfx2DGlue.h"
+
−#include "mozilla/DebugOnly.h"          // for DebugOnly
+
−#include "mozilla/IntegerPrintfMacros.h"
+
−#include "mozilla/Telemetry.h"          // for Accumulate
+
−#include "mozilla/ToString.h"
+
−#include "mozilla/gfx/2D.h"             // for DrawTarget
+
−#include "mozilla/gfx/BaseSize.h"       // for BaseSize
+
−#include "mozilla/gfx/Matrix.h"         // for Matrix4x4
+
−#include "mozilla/gfx/Polygon.h"        // for Polygon
+
−#include "mozilla/layers/AnimationHelper.h"
+
−#include "mozilla/layers/AsyncCanvasRenderer.h"
+
−#include "mozilla/layers/BSPTree.h"     // for BSPTree
+
−#include "mozilla/layers/CompositableClient.h"  // for CompositableClient
+
−#include "mozilla/layers/Compositor.h"  // for Compositor
+
−#include "mozilla/layers/CompositorTypes.h"
+
−#include "mozilla/layers/LayerManagerComposite.h"  // for LayerComposite
+
−#include "mozilla/layers/LayerMetricsWrapper.h" // for LayerMetricsWrapper
+
−#include "mozilla/layers/LayersMessages.h"  // for TransformFunction, etc
+
−#include "mozilla/layers/LayersTypes.h"  // for TextureDumpMode
+
−#include "mozilla/layers/PersistentBufferProvider.h"
+
−#include "mozilla/layers/ShadowLayers.h"  // for ShadowableLayer
+
−#include "nsAString.h"
+
−#include "nsCSSValue.h"                 // for nsCSSValue::Array, etc
+
−#include "nsDisplayList.h"              // for nsDisplayItem
+
−#include "nsPrintfCString.h"            // for nsPrintfCString
+
−#include "nsStyleStruct.h"              // for nsTimingFunction, etc
+
−#include "protobuf/LayerScopePacket.pb.h"
+
−#include "mozilla/Compression.h"
+
−#include "TreeTraversal.h"              // for ForEachNode
+
−
+
−#include <list>
+
−#include <set>
+
−
+
−uint8_t gLayerManagerLayerBuilder;
+
−
+
−namespace mozilla {
+
−namespace layers {
+
−
+
−FILE*
+
−FILEOrDefault(FILE* aFile)
+
−{
+
−  return aFile ? aFile : stderr;
+
−}
+
−
+
−typedef FrameMetrics::ViewID ViewID;
+
−
+
−using namespace mozilla::gfx;
+
−using namespace mozilla::Compression;
+
−
+
−//--------------------------------------------------
+
−// LayerManager
+
−
+
−/* static */ mozilla::LogModule*
+
−LayerManager::GetLog()
+
−{
+
−  static LazyLogModule sLog("Layers");
+
−  return sLog;
+
−}
+
−
+
−FrameMetrics::ViewID
+
−LayerManager::GetRootScrollableLayerId()
+
−{
+
−  if (!mRoot) {
+
−    return FrameMetrics::NULL_SCROLL_ID;
+
−  }
+
−
+
−  LayerMetricsWrapper layerMetricsRoot = LayerMetricsWrapper(mRoot);
+
−
+
−  LayerMetricsWrapper rootScrollableLayerMetrics =
+
−      BreadthFirstSearch<ForwardIterator>(
+
−          layerMetricsRoot,
+
−          [](LayerMetricsWrapper aLayerMetrics)
+
−          {
+
−            return aLayerMetrics.Metrics().IsScrollable();
+
−          }
+
−      );
+
−
+
−  return rootScrollableLayerMetrics.IsValid() ?
+
−      rootScrollableLayerMetrics.Metrics().GetScrollId() :
+
−      FrameMetrics::NULL_SCROLL_ID;
+
−}
+
−
+
−LayerMetricsWrapper
+
−LayerManager::GetRootContentLayer()
+
−{
+
−  if (!mRoot) {
+
−    return LayerMetricsWrapper();
+
−  }
+
−
+
−  LayerMetricsWrapper root(mRoot);
+
−
+
−  return BreadthFirstSearch<ForwardIterator>(root,
+
−      [](LayerMetricsWrapper aLayerMetrics)
+
−      {
+
−        return aLayerMetrics.Metrics().IsRootContent();
+
−      }
+
−  );
+
−}
+
−
+
−already_AddRefed<DrawTarget>
+
−LayerManager::CreateOptimalDrawTarget(const gfx::IntSize &aSize,
+
−                                      SurfaceFormat aFormat)
+
−{
+
−  return gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(aSize,
+
−                                                                      aFormat);
+
−}
+
−
+
−already_AddRefed<DrawTarget>
+
−LayerManager::CreateOptimalMaskDrawTarget(const gfx::IntSize &aSize)
+
−{
+
−  return CreateOptimalDrawTarget(aSize, SurfaceFormat::A8);
+
−}
+
−
+
−already_AddRefed<DrawTarget>
+
−LayerManager::CreateDrawTarget(const IntSize &aSize,
+
−                               SurfaceFormat aFormat)
+
−{
+
−  return gfxPlatform::GetPlatform()->
+
−    CreateOffscreenCanvasDrawTarget(aSize, aFormat);
+
−}
+
−
+
−already_AddRefed<PersistentBufferProvider>
+
−LayerManager::CreatePersistentBufferProvider(const mozilla::gfx::IntSize &aSize,
+
−                                             mozilla::gfx::SurfaceFormat aFormat)
+
−{
+
−  RefPtr<PersistentBufferProviderBasic> bufferProvider =
+
−    PersistentBufferProviderBasic::Create(aSize, aFormat,
+
−      gfxPlatform::GetPlatform()->GetPreferredCanvasBackend());
+
−
+
−  if (!bufferProvider) {
+
−    bufferProvider = PersistentBufferProviderBasic::Create(aSize, aFormat,
+
−      gfxPlatform::GetPlatform()->GetFallbackCanvasBackend());
+
−  }
+
−
+
−  return bufferProvider.forget();
+
−}
+
−
+
−already_AddRefed<ImageContainer>
+
−LayerManager::CreateImageContainer(ImageContainer::Mode flag)
+
−{
+
−  RefPtr<ImageContainer> container = new ImageContainer(flag);
+
−  return container.forget();
+
−}
+
−
+
−bool
+
−LayerManager::AreComponentAlphaLayersEnabled()
+
−{
+
−  return gfxPrefs::ComponentAlphaEnabled();
+
−}
+
−
+
−/*static*/ void
+
−LayerManager::LayerUserDataDestroy(void* data)
+
−{
+
−  delete static_cast<LayerUserData*>(data);
+
−}
+
−
+
−UniquePtr<LayerUserData>
+
−LayerManager::RemoveUserData(void* aKey)
+
−{
+
−  UniquePtr<LayerUserData> d(static_cast<LayerUserData*>(mUserData.Remove(static_cast<gfx::UserDataKey*>(aKey))));
+
−  return d;
+
−}
+
−
+
−//--------------------------------------------------
+
−// Layer
+
−
+
−Layer::Layer(LayerManager* aManager, void* aImplData) :
+
−  mManager(aManager),
+
−  mParent(nullptr),
+
−  mNextSibling(nullptr),
+
−  mPrevSibling(nullptr),
+
−  mImplData(aImplData),
+
−  mCompositorAnimationsId(0),
+
−  mUseTileSourceRect(false),
+
−#ifdef DEBUG
+
−  mDebugColorIndex(0),
+
−#endif
+
−  mAnimationGeneration(0)
+
−{
+
−}
+
−
+
−Layer::~Layer()
+
−{
+
−}
+
−
+
−void
+
−Layer::EnsureAnimationsId()
+
−{
+
−  if (!mCompositorAnimationsId) {
+
−    mCompositorAnimationsId = AnimationHelper::GetNextCompositorAnimationsId();
+
−  }
+
−}
+
−
+
−Animation*
+
−Layer::AddAnimation()
+
−{
+
−  // Here generates a new id when the first animation is added and
+
−  // this id is used to represent the animations in this layer.
+
−  EnsureAnimationsId();
+
−
+
−  MOZ_LAYERS_LOG_IF_SHADOWABLE(
+
−    this, ("Layer::Mutated(%p) AddAnimation with id=%" PRIu64, this, mCompositorAnimationsId));
+
−
+
−  MOZ_ASSERT(!mPendingAnimations, "should have called ClearAnimations first");
+
−
+
−  Animation* anim = mAnimations.AppendElement();
+
−
+
−  Mutated();
+
−  return anim;
+
−}
+
−
+
−void
+
−Layer::ClearAnimations()
+
−{
+
−  mPendingAnimations = nullptr;
+
−
+
−  if (mAnimations.IsEmpty() && mAnimationData.IsEmpty()) {
+
−    return;
+
−  }
+
−
+
−  MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ClearAnimations", this));
+
−  mAnimations.Clear();
+
−  mAnimationData.Clear();
+
−  Mutated();
+
−}
+
−
+
−Animation*
+
−Layer::AddAnimationForNextTransaction()
+
−{
+
−  MOZ_ASSERT(mPendingAnimations,
+
−             "should have called ClearAnimationsForNextTransaction first");
+
−
+
−  Animation* anim = mPendingAnimations->AppendElement();
+
−
+
−  return anim;
+
−}
+
−
+
−void
+
−Layer::ClearAnimationsForNextTransaction()
+
−{
+
−  // Ensure we have a non-null mPendingAnimations to mark a future clear.
+
−  if (!mPendingAnimations) {
+
−    mPendingAnimations = new AnimationArray;
+
−  }
+
−
+
−  mPendingAnimations->Clear();
+
−}
+
−
+
−void
+
−Layer::SetCompositorAnimations(const CompositorAnimations& aCompositorAnimations)
+
−{
+
−  MOZ_LAYERS_LOG_IF_SHADOWABLE(
+
−    this, ("Layer::Mutated(%p) SetCompositorAnimations with id=%" PRIu64, this, mCompositorAnimationsId));
+
−
+
−  mAnimations = aCompositorAnimations.animations();
+
−  mCompositorAnimationsId = aCompositorAnimations.id();
+
−  mAnimationData.Clear();
+
−  AnimationHelper::SetAnimations(mAnimations,
+
−                                 mAnimationData,
+
−                                 mBaseAnimationStyle);
+
−
+
−  Mutated();
+
−}
+
−
+
−void
+
−Layer::StartPendingAnimations(const TimeStamp& aReadyTime)
+
−{
+
−  ForEachNode<ForwardIterator>(
+
−      this,
+
−      [&aReadyTime](Layer *layer)
+
−      {
+
−        bool updated = false;
+
−        for (size_t animIdx = 0, animEnd = layer->mAnimations.Length();
+
−             animIdx < animEnd; animIdx++) {
+
−          Animation& anim = layer->mAnimations[animIdx];
+
−
+
−          // If the animation is play-pending, resolve the start time.
+
−          // This mirrors the calculation in Animation::StartTimeFromReadyTime.
+
−          if (anim.startTime().type() == MaybeTimeDuration::Tnull_t &&
+
−              !anim.originTime().IsNull() &&
+
−              !anim.isNotPlaying()) {
+
−            TimeDuration readyTime = aReadyTime - anim.originTime();
+
−            anim.startTime() =
+
−              anim.playbackRate() == 0
+
−              ? readyTime
+
−              : readyTime - anim.holdTime().MultDouble(1.0 /
+
−                                                       anim.playbackRate());
+
−            updated = true;
+
−          }
+
−        }
+
−        if (updated) {
+
−          layer->Mutated();
+
−        }
+
−      });
+
−}
+
−
+
−void
+
−Layer::SetAsyncPanZoomController(uint32_t aIndex, AsyncPanZoomController *controller)
+
−{
+
−  MOZ_ASSERT(aIndex < GetScrollMetadataCount());
+
−  mApzcs[aIndex] = controller;
+
−}
+
−
+
−AsyncPanZoomController*
+
−Layer::GetAsyncPanZoomController(uint32_t aIndex) const
+
−{
+
−  MOZ_ASSERT(aIndex < GetScrollMetadataCount());
+
−#ifdef DEBUG
+
−  if (mApzcs[aIndex]) {
+
−    MOZ_ASSERT(GetFrameMetrics(aIndex).IsScrollable());
+
−  }
+
−#endif
+
−  return mApzcs[aIndex];
+
−}
+
−
+
−void
+
−Layer::ScrollMetadataChanged()
+
−{
+
−  mApzcs.SetLength(GetScrollMetadataCount());
+
−}
+
−
+
−void
+
−Layer::ApplyPendingUpdatesToSubtree()
+
−{
+
−  ForEachNode<ForwardIterator>(
+
−      this,
+
−      [] (Layer *layer)
+
−      {
+
−        layer->ApplyPendingUpdatesForThisTransaction();
+
−      });
+
−
+
−  // Once we're done recursing through the whole tree, clear the pending
+
−  // updates from the manager.
+
−  Manager()->ClearPendingScrollInfoUpdate();
+
−}
+
−
+
−bool
+
−Layer::IsOpaqueForVisibility()
+
−{
+
−  return GetEffectiveOpacity() == 1.0f &&
+
−         GetEffectiveMixBlendMode() == CompositionOp::OP_OVER;
+
−}
+
−
+
−bool
+
−Layer::CanUseOpaqueSurface()
+
−{
+
−  // If the visible content in the layer is opaque, there is no need
+
−  // for an alpha channel.
+
−  if (GetContentFlags() & CONTENT_OPAQUE)
+
−    return true;
+
−  // Also, if this layer is the bottommost layer in a container which
+
−  // doesn't need an alpha channel, we can use an opaque surface for this
+
−  // layer too. Any transparent areas must be covered by something else
+
−  // in the container.
+
−  ContainerLayer* parent = GetParent();
+
−  return parent && parent->GetFirstChild() == this &&
+
−    parent->CanUseOpaqueSurface();
+
−}
+
−
+
−// NB: eventually these methods will be defined unconditionally, and
+
−// can be moved into Layers.h
+
−const Maybe<ParentLayerIntRect>&
+
−Layer::GetLocalClipRect()
+
−{
+
−  if (HostLayer* shadow = AsHostLayer()) {
+
−    return shadow->GetShadowClipRect();
+
−  }
+
−  return GetClipRect();
+
−}
+
−
+
−const LayerIntRegion&
+
−Layer::GetLocalVisibleRegion()
+
−{
+
−  if (HostLayer* shadow = AsHostLayer()) {
+
−    return shadow->GetShadowVisibleRegion();
+
−  }
+
−  return GetVisibleRegion();
+
−}
+
−
+
−Matrix4x4
+
−Layer::SnapTransformTranslation(const Matrix4x4& aTransform,
+
−                                Matrix* aResidualTransform)
+
−{
+
−  if (aResidualTransform) {
+
−    *aResidualTransform = Matrix();
+
−  }
+
−
+
−  if (!mManager->IsSnappingEffectiveTransforms()) {
+
−    return aTransform;
+
−  }
+
−
+
−  Matrix matrix2D;
+
−  if (aTransform.CanDraw2D(&matrix2D) &&
+
−      !matrix2D.HasNonTranslation() &&
+
−      matrix2D.HasNonIntegerTranslation()) {
+
−    auto snappedTranslation = IntPoint::Round(matrix2D.GetTranslation());
+
−    Matrix snappedMatrix = Matrix::Translation(snappedTranslation.x,
+
−                                               snappedTranslation.y);
+
−    Matrix4x4 result = Matrix4x4::From2D(snappedMatrix);
+
−    if (aResidualTransform) {
+
−      // set aResidualTransform so that aResidual * snappedMatrix == matrix2D.
+
−      // (I.e., appying snappedMatrix after aResidualTransform gives the
+
−      // ideal transform.)
+
−      *aResidualTransform =
+
−        Matrix::Translation(matrix2D._31 - snappedTranslation.x,
+
−                            matrix2D._32 - snappedTranslation.y);
+
−    }
+
−    return result;
+
−  }
+
−
+
−  return SnapTransformTranslation3D(aTransform, aResidualTransform);
+
−}
+
−
+
−Matrix4x4
+
−Layer::SnapTransformTranslation3D(const Matrix4x4& aTransform,
+
−                                  Matrix* aResidualTransform)
+
−{
+
−  if(aTransform.IsSingular() ||
+
−     aTransform.HasPerspectiveComponent() ||
+
−     aTransform.HasNonTranslation() ||
+
−     !aTransform.HasNonIntegerTranslation()) {
+
−    // For a singular transform, there is no reversed matrix, so we
+
−    // don't snap it.
+
−    // For a perspective transform, the content is transformed in
+
−    // non-linear, so we don't snap it too.
+
−    return aTransform;
+
−  }
+
−
+
−  // Snap for 3D Transforms
+
−
+
−  Point3D transformedOrigin = aTransform.TransformPoint(Point3D());
+
−
+
−  // Compute the transformed snap by rounding the values of
+
−  // transformed origin.
+
−  auto transformedSnapXY = IntPoint::Round(transformedOrigin.x, transformedOrigin.y);
+
−  Matrix4x4 inverse = aTransform;
+
−  inverse.Invert();
+
−  // see Matrix4x4::ProjectPoint()
+
−  Float transformedSnapZ =
+
−    inverse._33 == 0 ? 0 : (-(transformedSnapXY.x * inverse._13 +
+
−                              transformedSnapXY.y * inverse._23 +
+
−                              inverse._43) / inverse._33);
+
−  Point3D transformedSnap =
+
−    Point3D(transformedSnapXY.x, transformedSnapXY.y, transformedSnapZ);
+
−  if (transformedOrigin == transformedSnap) {
+
−    return aTransform;
+
−  }
+
−
+
−  // Compute the snap from the transformed snap.
+
−  Point3D snap = inverse.TransformPoint(transformedSnap);
+
−  if (snap.z > 0.001 || snap.z < -0.001) {
+
−    // Allow some level of accumulated computation error.
+
−    MOZ_ASSERT(inverse._33 == 0.0);
+
−    return aTransform;
+
−  }
+
−
+
−  // The difference between the origin and snap is the residual transform.
+
−  if (aResidualTransform) {
+
−    // The residual transform is to translate the snap to the origin
+
−    // of the content buffer.
+
−    *aResidualTransform = Matrix::Translation(-snap.x, -snap.y);
+
−  }
+
−
+
−  // Translate transformed origin to transformed snap since the
+
−  // residual transform would trnslate the snap to the origin.
+
−  Point3D transformedShift = transformedSnap - transformedOrigin;
+
−  Matrix4x4 result = aTransform;
+
−  result.PostTranslate(transformedShift.x,
+
−                       transformedShift.y,
+
−                       transformedShift.z);
+
−
+
−  // For non-2d transform, residual translation could be more than
+
−  // 0.5 pixels for every axis.
+
−
+
−  return result;
+
−}
+
−
+
−Matrix4x4
+
−Layer::SnapTransform(const Matrix4x4& aTransform,
+
−                     const gfxRect& aSnapRect,
+
−                     Matrix* aResidualTransform)
+
−{
+
−  if (aResidualTransform) {
+
−    *aResidualTransform = Matrix();
+
−  }
+
−
+
−  Matrix matrix2D;
+
−  Matrix4x4 result;
+
−  if (mManager->IsSnappingEffectiveTransforms() &&
+
−      aTransform.Is2D(&matrix2D) &&
+
−      gfxSize(1.0, 1.0) <= aSnapRect.Size() &&
+
−      matrix2D.PreservesAxisAlignedRectangles()) {
+
−    auto transformedTopLeft = IntPoint::Round(matrix2D.TransformPoint(ToPoint(aSnapRect.TopLeft())));
+
−    auto transformedTopRight = IntPoint::Round(matrix2D.TransformPoint(ToPoint(aSnapRect.TopRight())));
+
−    auto transformedBottomRight = IntPoint::Round(matrix2D.TransformPoint(ToPoint(aSnapRect.BottomRight())));
+
−
+
−    Matrix snappedMatrix = gfxUtils::TransformRectToRect(aSnapRect,
+
−      transformedTopLeft, transformedTopRight, transformedBottomRight);
+
−
+
−    result = Matrix4x4::From2D(snappedMatrix);
+
−    if (aResidualTransform && !snappedMatrix.IsSingular()) {
+
−      // set aResidualTransform so that aResidual * snappedMatrix == matrix2D.
+
−      // (i.e., appying snappedMatrix after aResidualTransform gives the
+
−      // ideal transform.
+
−      Matrix snappedMatrixInverse = snappedMatrix;
+
−      snappedMatrixInverse.Invert();
+
−      *aResidualTransform = matrix2D * snappedMatrixInverse;
+
−    }
+
−  } else {
+
−    result = aTransform;
+
−  }
+
−  return result;
+
−}
+
−
+
−static bool
+
−AncestorLayerMayChangeTransform(Layer* aLayer)
+
−{
+
−  for (Layer* l = aLayer; l; l = l->GetParent()) {
+
−    if (l->GetContentFlags() & Layer::CONTENT_MAY_CHANGE_TRANSFORM) {
+
−      return true;
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−bool
+
−Layer::MayResample()
+
−{
+
−  Matrix transform2d;
+
−  return !GetEffectiveTransform().Is2D(&transform2d) ||
+
−         ThebesMatrix(transform2d).HasNonIntegerTranslation() ||
+
−         AncestorLayerMayChangeTransform(this);
+
−}
+
−
+
−RenderTargetIntRect
+
−Layer::CalculateScissorRect(const RenderTargetIntRect& aCurrentScissorRect)
+
−{
+
−  ContainerLayer* container = GetParent();
+
−  ContainerLayer* containerChild = nullptr;
+
−  NS_ASSERTION(GetParent(), "This can't be called on the root!");
+
−
+
−  // Find the layer creating the 3D context.
+
−  while (container->Extend3DContext() &&
+
−         !container->UseIntermediateSurface()) {
+
−    containerChild = container;
+
−    container = container->GetParent();
+
−    MOZ_ASSERT(container);
+
−  }
+
−
+
−  // Find the nearest layer with a clip, or this layer.
+
−  // ContainerState::SetupScrollingMetadata() may install a clip on
+
−  // the layer.
+
−  Layer *clipLayer =
+
−    containerChild && containerChild->GetLocalClipRect() ?
+
−    containerChild : this;
+
−
+
−  // Establish initial clip rect: it's either the one passed in, or
+
−  // if the parent has an intermediate surface, it's the extents of that surface.
+
−  RenderTargetIntRect currentClip;
+
−  if (container->UseIntermediateSurface()) {
+
−    currentClip.SizeTo(container->GetIntermediateSurfaceRect().Size());
+
−  } else {
+
−    currentClip = aCurrentScissorRect;
+
−  }
+
−
+
−  if (!clipLayer->GetLocalClipRect()) {
+
−    return currentClip;
+
−  }
+
−
+
−  if (GetLocalVisibleRegion().IsEmpty()) {
+
−    // When our visible region is empty, our parent may not have created the
+
−    // intermediate surface that we would require for correct clipping; however,
+
−    // this does not matter since we are invisible.
+
−    // Make sure we still compute a clip rect if we want to draw checkboarding
+
−    // for this layer, since we want to do this even if the layer is invisible.
+
−    return RenderTargetIntRect(currentClip.TopLeft(), RenderTargetIntSize(0, 0));
+
−  }
+
−
+
−  const RenderTargetIntRect clipRect =
+
−    ViewAs<RenderTargetPixel>(*clipLayer->GetLocalClipRect(),
+
−                              PixelCastJustification::RenderTargetIsParentLayerForRoot);
+
−  if (clipRect.IsEmpty()) {
+
−    // We might have a non-translation transform in the container so we can't
+
−    // use the code path below.
+
−    return RenderTargetIntRect(currentClip.TopLeft(), RenderTargetIntSize(0, 0));
+
−  }
+
−
+
−  RenderTargetIntRect scissor = clipRect;
+
−  if (!container->UseIntermediateSurface()) {
+
−    gfx::Matrix matrix;
+
−    DebugOnly<bool> is2D = container->GetEffectiveTransform().Is2D(&matrix);
+
−    // See DefaultComputeEffectiveTransforms below
+
−    NS_ASSERTION(is2D && matrix.PreservesAxisAlignedRectangles(),
+
−                 "Non preserves axis aligned transform with clipped child should have forced intermediate surface");
+
−    gfx::Rect r(scissor.x, scissor.y, scissor.width, scissor.height);
+
−    gfxRect trScissor = gfx::ThebesRect(matrix.TransformBounds(r));
+
−    trScissor.Round();
+
−    IntRect tmp;
+
−    if (!gfxUtils::GfxRectToIntRect(trScissor, &tmp)) {
+
−      return RenderTargetIntRect(currentClip.TopLeft(), RenderTargetIntSize(0, 0));
+
−    }
+
−    scissor = ViewAs<RenderTargetPixel>(tmp);
+
−
+
−    // Find the nearest ancestor with an intermediate surface
+
−    do {
+
−      container = container->GetParent();
+
−    } while (container && !container->UseIntermediateSurface());
+
−  }
+
−
+
−  if (container) {
+
−    scissor.MoveBy(-container->GetIntermediateSurfaceRect().TopLeft());
+
−  }
+
−  return currentClip.Intersect(scissor);
+
−}
+
−
+
−Maybe<ParentLayerIntRect>
+
−Layer::GetScrolledClipRect() const
+
−{
+
−  const Maybe<LayerClip> clip = mSimpleAttrs.ScrolledClip();
+
−  return clip ? Some(clip->GetClipRect()) : Nothing();
+
−}
+
−
+
−const ScrollMetadata&
+
−Layer::GetScrollMetadata(uint32_t aIndex) const
+
−{
+
−  MOZ_ASSERT(aIndex < GetScrollMetadataCount());
+
−  return mScrollMetadata[aIndex];
+
−}
+
−
+
−const FrameMetrics&
+
−Layer::GetFrameMetrics(uint32_t aIndex) const
+
−{
+
−  return GetScrollMetadata(aIndex).GetMetrics();
+
−}
+
−
+
−bool
+
−Layer::HasScrollableFrameMetrics() const
+
−{
+
−  for (uint32_t i = 0; i < GetScrollMetadataCount(); i++) {
+
−    if (GetFrameMetrics(i).IsScrollable()) {
+
−      return true;
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−bool
+
−Layer::IsScrollInfoLayer() const
+
−{
+
−  // A scrollable container layer with no children
+
−  return AsContainerLayer()
+
−      && HasScrollableFrameMetrics()
+
−      && !GetFirstChild();
+
−}
+
−
+
−Matrix4x4
+
−Layer::GetTransform() const
+
−{
+
−  Matrix4x4 transform = mSimpleAttrs.Transform();
+
−  transform.PostScale(GetPostXScale(), GetPostYScale(), 1.0f);
+
−  if (const ContainerLayer* c = AsContainerLayer()) {
+
−    transform.PreScale(c->GetPreXScale(), c->GetPreYScale(), 1.0f);
+
−  }
+
−  return transform;
+
−}
+
−
+
−const CSSTransformMatrix
+
−Layer::GetTransformTyped() const
+
−{
+
−  return ViewAs<CSSTransformMatrix>(GetTransform());
+
−}
+
−
+
−Matrix4x4
+
−Layer::GetLocalTransform()
+
−{
+
−  if (HostLayer* shadow = AsHostLayer()) {
+
−    return shadow->GetShadowTransform();
+
−  }
+
−  return GetTransform();
+
−}
+
−
+
−const LayerToParentLayerMatrix4x4
+
−Layer::GetLocalTransformTyped()
+
−{
+
−  return ViewAs<LayerToParentLayerMatrix4x4>(GetLocalTransform());
+
−}
+
−
+
−bool
+
−Layer::HasOpacityAnimation() const
+
−{
+
−  for (uint32_t i = 0; i < mAnimations.Length(); i++) {
+
−    if (mAnimations[i].property() == eCSSProperty_opacity) {
+
−      return true;
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−bool
+
−Layer::HasTransformAnimation() const
+
−{
+
−  for (uint32_t i = 0; i < mAnimations.Length(); i++) {
+
−    if (mAnimations[i].property() == eCSSProperty_transform) {
+
−      return true;
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−void
+
−Layer::ApplyPendingUpdatesForThisTransaction()
+
−{
+
−  if (mPendingTransform && *mPendingTransform != mSimpleAttrs.Transform()) {
+
−    MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) PendingUpdatesForThisTransaction", this));
+
−    mSimpleAttrs.SetTransform(*mPendingTransform);
+
−    MutatedSimple();
+
−  }
+
−  mPendingTransform = nullptr;
+
−
+
−  if (mPendingAnimations) {
+
−    MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) PendingUpdatesForThisTransaction", this));
+
−    mPendingAnimations->SwapElements(mAnimations);
+
−    mPendingAnimations = nullptr;
+
−    Mutated();
+
−  }
+
−
+
−  for (size_t i = 0; i < mScrollMetadata.Length(); i++) {
+
−    FrameMetrics& fm = mScrollMetadata[i].GetMetrics();
+
−    Maybe<ScrollUpdateInfo> update = Manager()->GetPendingScrollInfoUpdate(fm.GetScrollId());
+
−    if (update) {
+
−      fm.UpdatePendingScrollInfo(update.value());
+
−      Mutated();
+
−    }
+
−  }
+
−}
+
−
+
−float
+
−Layer::GetLocalOpacity()
+
−{
+
−  float opacity = mSimpleAttrs.Opacity();
+
−  if (HostLayer* shadow = AsHostLayer())
+
−    opacity = shadow->GetShadowOpacity();
+
−  return std::min(std::max(opacity, 0.0f), 1.0f);
+
−}
+
−
+
−float
+
−Layer::GetEffectiveOpacity()
+
−{
+
−  float opacity = GetLocalOpacity();
+
−  for (ContainerLayer* c = GetParent(); c && !c->UseIntermediateSurface();
+
−       c = c->GetParent()) {
+
−    opacity *= c->GetLocalOpacity();
+
−  }
+
−  return opacity;
+
−}
+
−
+
−CompositionOp
+
−Layer::GetEffectiveMixBlendMode()
+
−{
+
−  if (mSimpleAttrs.MixBlendMode() != CompositionOp::OP_OVER)
+
−    return mSimpleAttrs.MixBlendMode();
+
−  for (ContainerLayer* c = GetParent(); c && !c->UseIntermediateSurface();
+
−    c = c->GetParent()) {
+
−    if(c->mSimpleAttrs.MixBlendMode() != CompositionOp::OP_OVER)
+
−      return c->mSimpleAttrs.MixBlendMode();
+
−  }
+
−
+
−  return mSimpleAttrs.MixBlendMode();
+
−}
+
−
+
−void
+
−Layer::ComputeEffectiveTransformForMaskLayers(const gfx::Matrix4x4& aTransformToSurface)
+
−{
+
−  if (GetMaskLayer()) {
+
−    ComputeEffectiveTransformForMaskLayer(GetMaskLayer(), aTransformToSurface);
+
−  }
+
−  for (size_t i = 0; i < GetAncestorMaskLayerCount(); i++) {
+
−    Layer* maskLayer = GetAncestorMaskLayerAt(i);
+
−    ComputeEffectiveTransformForMaskLayer(maskLayer, aTransformToSurface);
+
−  }
+
−}
+
−
+
−/* static */ void
+
−Layer::ComputeEffectiveTransformForMaskLayer(Layer* aMaskLayer, const gfx::Matrix4x4& aTransformToSurface)
+
−{
+
−  aMaskLayer->mEffectiveTransform = aTransformToSurface;
+
−
+
−#ifdef DEBUG
+
−  bool maskIs2D = aMaskLayer->GetTransform().CanDraw2D();
+
−  NS_ASSERTION(maskIs2D, "How did we end up with a 3D transform here?!");
+
−#endif
+
−  // The mask layer can have an async transform applied to it in some
+
−  // situations, so be sure to use its GetLocalTransform() rather than
+
−  // its GetTransform().
+
−  aMaskLayer->mEffectiveTransform = aMaskLayer->GetLocalTransform() *
+
−    aMaskLayer->mEffectiveTransform;
+
−}
+
−
+
−RenderTargetRect
+
−Layer::TransformRectToRenderTarget(const LayerIntRect& aRect)
+
−{
+
−  LayerRect rect(aRect);
+
−  RenderTargetRect quad = RenderTargetRect::FromUnknownRect(
+
−    GetEffectiveTransform().TransformBounds(rect.ToUnknownRect()));
+
−  return quad;
+
−}
+
−
+
−bool
+
−Layer::GetVisibleRegionRelativeToRootLayer(nsIntRegion& aResult,
+
−                                           IntPoint* aLayerOffset)
+
−{
+
−  MOZ_ASSERT(aLayerOffset, "invalid offset pointer");
+
−
+
−  if (!GetParent()) {
+
−    return false;
+
−  }
+
−
+
−  IntPoint offset;
+
−  aResult = GetLocalVisibleRegion().ToUnknownRegion();
+
−  for (Layer* layer = this; layer; layer = layer->GetParent()) {
+
−    gfx::Matrix matrix;
+
−    if (!layer->GetLocalTransform().Is2D(&matrix) ||
+
−        !matrix.IsTranslation()) {
+
−      return false;
+
−    }
+
−
+
−    // The offset of |layer| to its parent.
+
−    auto currentLayerOffset = IntPoint::Round(matrix.GetTranslation());
+
−
+
−    // Translate the accumulated visible region of |this| by the offset of
+
−    // |layer|.
+
−    aResult.MoveBy(currentLayerOffset.x, currentLayerOffset.y);
+
−
+
−    // If the parent layer clips its lower layers, clip the visible region
+
−    // we're accumulating.
+
−    if (layer->GetLocalClipRect()) {
+
−      aResult.AndWith(layer->GetLocalClipRect()->ToUnknownRect());
+
−    }
+
−
+
−    // Now we need to walk across the list of siblings for this parent layer,
+
−    // checking to see if any of these layer trees obscure |this|. If so,
+
−    // remove these areas from the visible region as well. This will pick up
+
−    // chrome overlays like a tab modal prompt.
+
−    Layer* sibling;
+
−    for (sibling = layer->GetNextSibling(); sibling;
+
−         sibling = sibling->GetNextSibling()) {
+
−      gfx::Matrix siblingMatrix;
+
−      if (!sibling->GetLocalTransform().Is2D(&siblingMatrix) ||
+
−          !siblingMatrix.IsTranslation()) {
+
−        continue;
+
−      }
+
−
+
−      // Retreive the translation from sibling to |layer|. The accumulated
+
−      // visible region is currently oriented with |layer|.
+
−      auto siblingOffset = IntPoint::Round(siblingMatrix.GetTranslation());
+
−      nsIntRegion siblingVisibleRegion(sibling->GetLocalVisibleRegion().ToUnknownRegion());
+
−      // Translate the siblings region to |layer|'s origin.
+
−      siblingVisibleRegion.MoveBy(-siblingOffset.x, -siblingOffset.y);
+
−      // Apply the sibling's clip.
+
−      // Layer clip rects are not affected by the layer's transform.
+
−      Maybe<ParentLayerIntRect> clipRect = sibling->GetLocalClipRect();
+
−      if (clipRect) {
+
−        siblingVisibleRegion.AndWith(clipRect->ToUnknownRect());
+
−      }
+
−      // Subtract the sibling visible region from the visible region of |this|.
+
−      aResult.SubOut(siblingVisibleRegion);
+
−    }
+
−
+
−    // Keep track of the total offset for aLayerOffset.  We use this in plugin
+
−    // positioning code.
+
−    offset += currentLayerOffset;
+
−  }
+
−
+
−  *aLayerOffset = IntPoint(offset.x, offset.y);
+
−  return true;
+
−}
+
−
+
−Maybe<ParentLayerIntRect>
+
−Layer::GetCombinedClipRect() const
+
−{
+
−  Maybe<ParentLayerIntRect> clip = GetClipRect();
+
−
+
−  clip = IntersectMaybeRects(clip, GetScrolledClipRect());
+
−
+
−  for (size_t i = 0; i < mScrollMetadata.Length(); i++) {
+
−    clip = IntersectMaybeRects(clip, mScrollMetadata[i].GetClipRect());
+
−  }
+
−
+
−  return clip;
+
−}
+
−
+
−ContainerLayer::ContainerLayer(LayerManager* aManager, void* aImplData)
+
−  : Layer(aManager, aImplData),
+
−    mFirstChild(nullptr),
+
−    mLastChild(nullptr),
+
−    mPreXScale(1.0f),
+
−    mPreYScale(1.0f),
+
−    mInheritedXScale(1.0f),
+
−    mInheritedYScale(1.0f),
+
−    mPresShellResolution(1.0f),
+
−    mScaleToResolution(false),
+
−    mUseIntermediateSurface(false),
+
−    mSupportsComponentAlphaChildren(false),
+
−    mMayHaveReadbackChild(false),
+
−    mChildrenChanged(false),
+
−    mEventRegionsOverride(EventRegionsOverride::NoOverride)
+
−{
+
−}
+
−
+
−ContainerLayer::~ContainerLayer()
+
−{
+
−}
+
−
+
−bool
+
−ContainerLayer::InsertAfter(Layer* aChild, Layer* aAfter)
+
−{
+
−  if(aChild->Manager() != Manager()) {
+
−    NS_ERROR("Child has wrong manager");
+
−    return false;
+
−  }
+
−  if(aChild->GetParent()) {
+
−    NS_ERROR("aChild already in the tree");
+
−    return false;
+
−  }
+
−  if (aChild->GetNextSibling() || aChild->GetPrevSibling()) {
+
−    NS_ERROR("aChild already has siblings?");
+
−    return false;
+
−  }
+
−  if (aAfter && (aAfter->Manager() != Manager() ||
+
−                 aAfter->GetParent() != this))
+
−  {
+
−    NS_ERROR("aAfter is not our child");
+
−    return false;
+
−  }
+
−
+
−  aChild->SetParent(this);
+
−  if (aAfter == mLastChild) {
+
−    mLastChild = aChild;
+
−  }
+
−  if (!aAfter) {
+
−    aChild->SetNextSibling(mFirstChild);
+
−    if (mFirstChild) {
+
−      mFirstChild->SetPrevSibling(aChild);
+
−    }
+
−    mFirstChild = aChild;
+
−    NS_ADDREF(aChild);
+
−    DidInsertChild(aChild);
+
−    return true;
+
−  }
+
−
+
−  Layer* next = aAfter->GetNextSibling();
+
−  aChild->SetNextSibling(next);
+
−  aChild->SetPrevSibling(aAfter);
+
−  if (next) {
+
−    next->SetPrevSibling(aChild);
+
−  }
+
−  aAfter->SetNextSibling(aChild);
+
−  NS_ADDREF(aChild);
+
−  DidInsertChild(aChild);
+
−  return true;
+
−}
+
−
+
−void
+
−ContainerLayer::RemoveAllChildren()
+
−{
+
−  // Optimizes "while (mFirstChild) ContainerLayer::RemoveChild(mFirstChild);"
+
−  Layer* current = mFirstChild;
+
−
+
−  // This is inlining DidRemoveChild() on each layer; we can skip the calls
+
−  // to NotifyPaintedLayerRemoved as it gets taken care of when as we call
+
−  // NotifyRemoved prior to removing any layers.
+
−  while (current) {
+
−    Layer* next = current->GetNextSibling();
+
−    if (current->GetType() == TYPE_READBACK) {
+
−      static_cast<ReadbackLayer*>(current)->NotifyRemoved();
+
−    }
+
−    current = next;
+
−  }
+
−
+
−  current = mFirstChild;
+
−  mFirstChild = nullptr;
+
−  while (current) {
+
−    MOZ_ASSERT(!current->GetPrevSibling());
+
−
+
−    Layer* next = current->GetNextSibling();
+
−    current->SetParent(nullptr);
+
−    current->SetNextSibling(nullptr);
+
−    if (next) {
+
−      next->SetPrevSibling(nullptr);
+
−    }
+
−    NS_RELEASE(current);
+
−    current = next;
+
−  }
+
−}
+
−
+
−// Note that ContainerLayer::RemoveAllChildren is an optimized
+
−// version of this code; if you make changes to ContainerLayer::RemoveChild
+
−// consider whether the matching changes need to be made to
+
−// ContainerLayer::RemoveAllChildren
+
−bool
+
−ContainerLayer::RemoveChild(Layer *aChild)
+
−{
+
−  if (aChild->Manager() != Manager()) {
+
−    NS_ERROR("Child has wrong manager");
+
−    return false;
+
−  }
+
−  if (aChild->GetParent() != this) {
+
−    NS_ERROR("aChild not our child");
+
−    return false;
+
−  }
+
−
+
−  Layer* prev = aChild->GetPrevSibling();
+
−  Layer* next = aChild->GetNextSibling();
+
−  if (prev) {
+
−    prev->SetNextSibling(next);
+
−  } else {
+
−    this->mFirstChild = next;
+
−  }
+
−  if (next) {
+
−    next->SetPrevSibling(prev);
+
−  } else {
+
−    this->mLastChild = prev;
+
−  }
+
−
+
−  aChild->SetNextSibling(nullptr);
+
−  aChild->SetPrevSibling(nullptr);
+
−  aChild->SetParent(nullptr);
+
−
+
−  this->DidRemoveChild(aChild);
+
−  NS_RELEASE(aChild);
+
−  return true;
+
−}
+
−
+
−
+
−bool
+
−ContainerLayer::RepositionChild(Layer* aChild, Layer* aAfter)
+
−{
+
−  if (aChild->Manager() != Manager()) {
+
−    NS_ERROR("Child has wrong manager");
+
−    return false;
+
−  }
+
−  if (aChild->GetParent() != this) {
+
−    NS_ERROR("aChild not our child");
+
−    return false;
+
−  }
+
−  if (aAfter && (aAfter->Manager() != Manager() ||
+
−                 aAfter->GetParent() != this))
+
−  {
+
−    NS_ERROR("aAfter is not our child");
+
−    return false;
+
−  }
+
−  if (aChild == aAfter) {
+
−    NS_ERROR("aChild cannot be the same as aAfter");
+
−    return false;
+
−  }
+
−
+
−  Layer* prev = aChild->GetPrevSibling();
+
−  Layer* next = aChild->GetNextSibling();
+
−  if (prev == aAfter) {
+
−    // aChild is already in the correct position, nothing to do.
+
−    return true;
+
−  }
+
−  if (prev) {
+
−    prev->SetNextSibling(next);
+
−  } else {
+
−    mFirstChild = next;
+
−  }
+
−  if (next) {
+
−    next->SetPrevSibling(prev);
+
−  } else {
+
−    mLastChild = prev;
+
−  }
+
−  if (!aAfter) {
+
−    aChild->SetPrevSibling(nullptr);
+
−    aChild->SetNextSibling(mFirstChild);
+
−    if (mFirstChild) {
+
−      mFirstChild->SetPrevSibling(aChild);
+
−    }
+
−    mFirstChild = aChild;
+
−    return true;
+
−  }
+
−
+
−  Layer* afterNext = aAfter->GetNextSibling();
+
−  if (afterNext) {
+
−    afterNext->SetPrevSibling(aChild);
+
−  } else {
+
−    mLastChild = aChild;
+
−  }
+
−  aAfter->SetNextSibling(aChild);
+
−  aChild->SetPrevSibling(aAfter);
+
−  aChild->SetNextSibling(afterNext);
+
−  return true;
+
−}
+
−
+
−void
+
−ContainerLayer::FillSpecificAttributes(SpecificLayerAttributes& aAttrs)
+
−{
+
−  aAttrs = ContainerLayerAttributes(mPreXScale, mPreYScale,
+
−                                    mInheritedXScale, mInheritedYScale,
+
−                                    mPresShellResolution, mScaleToResolution,
+
−                                    mEventRegionsOverride);
+
−}
+
−
+
−bool
+
−ContainerLayer::Creates3DContextWithExtendingChildren()
+
−{
+
−  if (Extend3DContext()) {
+
−    return false;
+
−  }
+
−  for (Layer* child = GetFirstChild();
+
−       child;
+
−       child = child->GetNextSibling()) {
+
−      if (child->Extend3DContext()) {
+
−        return true;
+
−      }
+
−  }
+
−  return false;
+
−}
+
−
+
−bool
+
−ContainerLayer::HasMultipleChildren()
+
−{
+
−  uint32_t count = 0;
+
−  for (Layer* child = GetFirstChild(); child; child = child->GetNextSibling()) {
+
−    const Maybe<ParentLayerIntRect>& clipRect = child->GetLocalClipRect();
+
−    if (clipRect && clipRect->IsEmpty())
+
−      continue;
+
−    if (child->GetLocalVisibleRegion().IsEmpty())
+
−      continue;
+
−    ++count;
+
−    if (count > 1)
+
−      return true;
+
−  }
+
−
+
−  return false;
+
−}
+
−
+
−/**
+
− * Collect all leaf descendants of the current 3D context.
+
− */
+
−void
+
−ContainerLayer::Collect3DContextLeaves(nsTArray<Layer*>& aToSort)
+
−{
+
−  ForEachNode<ForwardIterator>(
+
−      (Layer*) this,
+
−      [this, &aToSort](Layer* layer)
+
−      {
+
−        ContainerLayer* container = layer->AsContainerLayer();
+
−        if (layer == this || (container && container->Extend3DContext() &&
+
−            !container->UseIntermediateSurface())) {
+
−          return TraversalFlag::Continue;
+
−        }
+
−        aToSort.AppendElement(layer);
+
−        return TraversalFlag::Skip;
+
−      }
+
−  );
+
−}
+
−
+
−static nsTArray<LayerPolygon>
+
−SortLayersWithBSPTree(nsTArray<Layer*>& aArray)
+
−{
+
−  std::list<LayerPolygon> inputLayers;
+
−
+
−  // Build a list of polygons to be sorted.
+
−  for (Layer* layer : aArray) {
+
−    // Ignore invisible layers.
+
−    if (!layer->IsVisible()) {
+
−      continue;
+
−    }
+
−
+
−    const gfx::IntRect& bounds =
+
−      layer->GetLocalVisibleRegion().ToUnknownRegion().GetBounds();
+
−
+
−    const gfx::Matrix4x4& transform = layer->GetEffectiveTransform();
+
−
+
−    if (transform.IsSingular()) {
+
−      // Transform cannot be inverted.
+
−      continue;
+
−    }
+
−
+
−    gfx::Polygon polygon = gfx::Polygon::FromRect(gfx::Rect(bounds));
+
−
+
−    // Transform the polygon to screen space.
+
−    polygon.TransformToScreenSpace(transform);
+
−
+
−    if (polygon.GetPoints().Length() >= 3) {
+
−      inputLayers.push_back(LayerPolygon(layer, Move(polygon)));
+
−    }
+
−  }
+
−
+
−  if (inputLayers.empty()) {
+
−    return nsTArray<LayerPolygon>();
+
−  }
+
−
+
−  // Build a BSP tree from the list of polygons.
+
−  BSPTree tree(inputLayers);
+
−
+
−  nsTArray<LayerPolygon> orderedLayers(tree.GetDrawOrder());
+
−
+
−  // Transform the polygons back to layer space.
+
−  for (LayerPolygon& layerPolygon : orderedLayers) {
+
−    gfx::Matrix4x4 inverse =
+
−      layerPolygon.layer->GetEffectiveTransform().Inverse();
+
−
+
−    MOZ_ASSERT(layerPolygon.geometry);
+
−    layerPolygon.geometry->TransformToLayerSpace(inverse);
+
−  }
+
−
+
−  return orderedLayers;
+
−}
+
−
+
−static nsTArray<LayerPolygon>
+
−StripLayerGeometry(const nsTArray<LayerPolygon>& aLayers)
+
−{
+
−  nsTArray<LayerPolygon> layers;
+
−  std::set<Layer*> uniqueLayers;
+
−
+
−  for (const LayerPolygon& layerPolygon : aLayers) {
+
−    auto result = uniqueLayers.insert(layerPolygon.layer);
+
−
+
−    if (result.second) {
+
−      // Layer was added to the set.
+
−      layers.AppendElement(LayerPolygon(layerPolygon.layer));
+
−    }
+
−  }
+
−
+
−  return layers;
+
−}
+
−
+
−nsTArray<LayerPolygon>
+
−ContainerLayer::SortChildrenBy3DZOrder(SortMode aSortMode)
+
−{
+
−  AutoTArray<Layer*, 10> toSort;
+
−  nsTArray<LayerPolygon> drawOrder;
+
−
+
−  for (Layer* layer = GetFirstChild(); layer; layer = layer->GetNextSibling()) {
+
−    ContainerLayer* container = layer->AsContainerLayer();
+
−
+
−    if (container && container->Extend3DContext() &&
+
−        !container->UseIntermediateSurface()) {
+
−
+
−      // Collect 3D layers in toSort array.
+
−      container->Collect3DContextLeaves(toSort);
+
−
+
−      // Sort the 3D layers.
+
−      if (toSort.Length() > 0) {
+
−        nsTArray<LayerPolygon> sorted = SortLayersWithBSPTree(toSort);
+
−        drawOrder.AppendElements(Move(sorted));
+
−
+
−        toSort.ClearAndRetainStorage();
+
−      }
+
−
+
−      continue;
+
−    }
+
−
+
−    drawOrder.AppendElement(LayerPolygon(layer));
+
−  }
+
−
+
−  if (aSortMode == SortMode::WITHOUT_GEOMETRY) {
+
−    // Compositor does not support arbitrary layers, strip the layer geometry
+
−    // and duplicate layers.
+
−    return StripLayerGeometry(drawOrder);
+
−  }
+
−
+
−  return drawOrder;
+
−}
+
−
+
−bool
+
−ContainerLayer::AnyAncestorOrThisIs3DContextLeaf()
+
−{
+
−  Layer* parent = this;
+
−  while (parent != nullptr) {
+
−    if (parent->Is3DContextLeaf()) {
+
−      return true;
+
−    }
+
−
+
−    parent = parent->GetParent();
+
−  }
+
−
+
−  return false;
+
−}
+
−
+
−void
+
−ContainerLayer::DefaultComputeEffectiveTransforms(const Matrix4x4& aTransformToSurface)
+
−{
+
−  Matrix residual;
+
−  Matrix4x4 idealTransform = GetLocalTransform() * aTransformToSurface;
+
−
+
−  // Keep 3D transforms for leaves to keep z-order sorting correct.
+
−  if (!Extend3DContext() && !Is3DContextLeaf()) {
+
−    idealTransform.ProjectTo2D();
+
−  }
+
−
+
−  bool useIntermediateSurface;
+
−  if (HasMaskLayers() ||
+
−      GetForceIsolatedGroup()) {
+
−    useIntermediateSurface = true;
+
−#ifdef MOZ_DUMP_PAINTING
+
−  } else if (gfxEnv::DumpPaintIntermediate() && !Extend3DContext()) {
+
−    useIntermediateSurface = true;
+
−#endif
+
−  } else {
+
−    /* Don't use an intermediate surface for opacity when it's within a 3d
+
−     * context, since we'd rather keep the 3d effects. This matches the
+
−     * WebKit/blink behaviour, but is changing in the latest spec.
+
−     */
+
−    float opacity = GetEffectiveOpacity();
+
−    CompositionOp blendMode = GetEffectiveMixBlendMode();
+
−    if ((HasMultipleChildren() || Creates3DContextWithExtendingChildren()) &&
+
−        ((opacity != 1.0f && !Extend3DContext()) ||
+
−         (blendMode != CompositionOp::OP_OVER))) {
+
−      useIntermediateSurface = true;
+
−    } else if ((!idealTransform.Is2D() || AnyAncestorOrThisIs3DContextLeaf()) &&
+
−               Creates3DContextWithExtendingChildren()) {
+
−      useIntermediateSurface = true;
+
−    } else if (blendMode != CompositionOp::OP_OVER &&
+
−               Manager()->BlendingRequiresIntermediateSurface()) {
+
−      useIntermediateSurface = true;
+
−    } else {
+
−      useIntermediateSurface = false;
+
−      gfx::Matrix contTransform;
+
−      bool checkClipRect = false;
+
−      bool checkMaskLayers = false;
+
−
+
−      if (!idealTransform.Is2D(&contTransform)) {
+
−        // In 3D case, always check if we should use IntermediateSurface.
+
−        checkClipRect = true;
+
−        checkMaskLayers = true;
+
−      } else {
+
−#ifdef MOZ_GFX_OPTIMIZE_MOBILE
+
−        if (!contTransform.PreservesAxisAlignedRectangles()) {
+
−#else
+
−        if (gfx::ThebesMatrix(contTransform).HasNonIntegerTranslation()) {
+
−#endif
+
−          checkClipRect = true;
+
−        }
+
−        /* In 2D case, only translation and/or positive scaling can be done w/o using IntermediateSurface.
+
−         * Otherwise, when rotation or flip happen, we should check whether to use IntermediateSurface.
+
−         */
+
−        if (contTransform.HasNonAxisAlignedTransform() || contTransform.HasNegativeScaling()) {
+
−          checkMaskLayers = true;
+
−        }
+
−      }
+
−
+
−      if (checkClipRect || checkMaskLayers) {
+
−        for (Layer* child = GetFirstChild(); child; child = child->GetNextSibling()) {
+
−          const Maybe<ParentLayerIntRect>& clipRect = child->GetLocalClipRect();
+
−          /* We can't (easily) forward our transform to children with a non-empty clip
+
−           * rect since it would need to be adjusted for the transform. See
+
−           * the calculations performed by CalculateScissorRect above.
+
−           * Nor for a child with a mask layer.
+
−           */
+
−          if (checkClipRect && (clipRect && !clipRect->IsEmpty() && !child->GetLocalVisibleRegion().IsEmpty())) {
+
−            useIntermediateSurface = true;
+
−            break;
+
−          }
+
−          if (checkMaskLayers && child->HasMaskLayers()) {
+
−            useIntermediateSurface = true;
+
−            break;
+
−          }
+
−        }
+
−      }
+
−    }
+
−  }
+
−
+
−  NS_ASSERTION(!Extend3DContext() || !useIntermediateSurface, "Can't have an intermediate surface with preserve-3d!");
+
−
+
−  if (useIntermediateSurface) {
+
−    mEffectiveTransform = SnapTransformTranslation(idealTransform, &residual);
+
−  } else {
+
−    mEffectiveTransform = idealTransform;
+
−  }
+
−
+
−  // For layers extending 3d context, its ideal transform should be
+
−  // applied on children.
+
−  if (!Extend3DContext()) {
+
−    // Without this projection, non-container children would get a 3D
+
−    // transform while 2D is expected.
+
−    idealTransform.ProjectTo2D();
+
−  }
+
−  mUseIntermediateSurface = useIntermediateSurface && !GetLocalVisibleRegion().IsEmpty();
+
−  if (useIntermediateSurface) {
+
−    ComputeEffectiveTransformsForChildren(Matrix4x4::From2D(residual));
+
−  } else {
+
−    ComputeEffectiveTransformsForChildren(idealTransform);
+
−  }
+
−
+
−  ComputeEffectiveTransformForMaskLayers(aTransformToSurface);
+
−}
+
−
+
−void
+
−ContainerLayer::DefaultComputeSupportsComponentAlphaChildren(bool* aNeedsSurfaceCopy)
+
−{
+
−  if (!(GetContentFlags() & Layer::CONTENT_COMPONENT_ALPHA_DESCENDANT) ||
+
−      !Manager()->AreComponentAlphaLayersEnabled()) {
+
−    mSupportsComponentAlphaChildren = false;
+
−    if (aNeedsSurfaceCopy) {
+
−      *aNeedsSurfaceCopy = false;
+
−    }
+
−    return;
+
−  }
+
−
+
−  mSupportsComponentAlphaChildren = false;
+
−  bool needsSurfaceCopy = false;
+
−  CompositionOp blendMode = GetEffectiveMixBlendMode();
+
−  if (UseIntermediateSurface()) {
+
−    if (GetLocalVisibleRegion().GetNumRects() == 1 &&
+
−        (GetContentFlags() & Layer::CONTENT_OPAQUE))
+
−    {
+
−      mSupportsComponentAlphaChildren = true;
+
−    } else {
+
−      gfx::Matrix transform;
+
−      if (HasOpaqueAncestorLayer(this) &&
+
−          GetEffectiveTransform().Is2D(&transform) &&
+
−          !gfx::ThebesMatrix(transform).HasNonIntegerTranslation() &&
+
−          blendMode == gfx::CompositionOp::OP_OVER &&
+
−          Manager()->SupportsBackdropCopyForComponentAlpha())
+
−      {
+
−        mSupportsComponentAlphaChildren = true;
+
−        needsSurfaceCopy = true;
+
−      }
+
−    }
+
−  } else if (blendMode == gfx::CompositionOp::OP_OVER) {
+
−    mSupportsComponentAlphaChildren =
+
−      (GetContentFlags() & Layer::CONTENT_OPAQUE) ||
+
−      (GetParent() && GetParent()->SupportsComponentAlphaChildren());
+
−  }
+
−
+
−  if (aNeedsSurfaceCopy) {
+
−    *aNeedsSurfaceCopy = mSupportsComponentAlphaChildren && needsSurfaceCopy;
+
−  }
+
−}
+
−
+
−void
+
−ContainerLayer::ComputeEffectiveTransformsForChildren(const Matrix4x4& aTransformToSurface)
+
−{
+
−  for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
+
−    l->ComputeEffectiveTransforms(aTransformToSurface);
+
−  }
+
−}
+
−
+
−/* static */ bool
+
−ContainerLayer::HasOpaqueAncestorLayer(Layer* aLayer)
+
−{
+
−  for (Layer* l = aLayer->GetParent(); l; l = l->GetParent()) {
+
−    if (l->GetContentFlags() & Layer::CONTENT_OPAQUE)
+
−      return true;
+
−  }
+
−  return false;
+
−}
+
−
+
−// Note that ContainerLayer::RemoveAllChildren contains an optimized
+
−// version of this code; if you make changes to ContainerLayer::DidRemoveChild
+
−// consider whether the matching changes need to be made to
+
−// ContainerLayer::RemoveAllChildren
+
−void
+
−ContainerLayer::DidRemoveChild(Layer* aLayer)
+
−{
+
−  PaintedLayer* tl = aLayer->AsPaintedLayer();
+
−  if (tl && tl->UsedForReadback()) {
+
−    for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
+
−      if (l->GetType() == TYPE_READBACK) {
+
−        static_cast<ReadbackLayer*>(l)->NotifyPaintedLayerRemoved(tl);
+
−      }
+
−    }
+
−  }
+
−  if (aLayer->GetType() == TYPE_READBACK) {
+
−    static_cast<ReadbackLayer*>(aLayer)->NotifyRemoved();
+
−  }
+
−}
+
−
+
−void
+
−ContainerLayer::DidInsertChild(Layer* aLayer)
+
−{
+
−  if (aLayer->GetType() == TYPE_READBACK) {
+
−    mMayHaveReadbackChild = true;
+
−  }
+
−}
+
−
+
−void
+
−RefLayer::FillSpecificAttributes(SpecificLayerAttributes& aAttrs)
+
−{
+
−  aAttrs = RefLayerAttributes(GetReferentId(), mEventRegionsOverride);
+
−}
+
−
+
−/**
+
− * StartFrameTimeRecording, together with StopFrameTimeRecording
+
− * enable recording of frame intervals.
+
− *
+
− * To allow concurrent consumers, a cyclic array is used which serves all
+
− * consumers, practically stateless with regard to consumers.
+
− *
+
− * To save resources, the buffer is allocated on first call to StartFrameTimeRecording
+
− * and recording is paused if no consumer which called StartFrameTimeRecording is able
+
− * to get valid results (because the cyclic buffer was overwritten since that call).
+
− *
+
− * To determine availability of the data upon StopFrameTimeRecording:
+
− * - mRecording.mNextIndex increases on each RecordFrame, and never resets.
+
− * - Cyclic buffer position is realized as mNextIndex % bufferSize.
+
− * - StartFrameTimeRecording returns mNextIndex. When StopFrameTimeRecording is called,
+
− *   the required start index is passed as an arg, and we're able to calculate the required
+
− *   length. If this length is bigger than bufferSize, it means data was overwritten.
+
− *   otherwise, we can return the entire sequence.
+
− * - To determine if we need to pause, mLatestStartIndex is updated to mNextIndex
+
− *   on each call to StartFrameTimeRecording. If this index gets overwritten,
+
− *   it means that all earlier start indices obtained via StartFrameTimeRecording
+
− *   were also overwritten, hence, no point in recording, so pause.
+
− * - mCurrentRunStartIndex indicates the oldest index of the recording after which
+
− *   the recording was not paused. If StopFrameTimeRecording is invoked with a start index
+
− *   older than this, it means that some frames were not recorded, so data is invalid.
+
− */
+
−uint32_t
+
−LayerManager::StartFrameTimeRecording(int32_t aBufferSize)
+
−{
+
−  if (mRecording.mIsPaused) {
+
−    mRecording.mIsPaused = false;
+
−
+
−    if (!mRecording.mIntervals.Length()) { // Initialize recording buffers
+
−      mRecording.mIntervals.SetLength(aBufferSize);
+
−    }
+
−
+
−    // After being paused, recent values got invalid. Update them to now.
+
−    mRecording.mLastFrameTime = TimeStamp::Now();
+
−
+
−    // Any recording which started before this is invalid, since we were paused.
+
−    mRecording.mCurrentRunStartIndex = mRecording.mNextIndex;
+
−  }
+
−
+
−  // If we'll overwrite this index, there are no more consumers with aStartIndex
+
−  // for which we're able to provide the full recording, so no point in keep recording.
+
−  mRecording.mLatestStartIndex = mRecording.mNextIndex;
+
−  return mRecording.mNextIndex;
+
−}
+
−
+
−void
+
−LayerManager::RecordFrame()
+
−{
+
−  if (!mRecording.mIsPaused) {
+
−    TimeStamp now = TimeStamp::Now();
+
−    uint32_t i = mRecording.mNextIndex % mRecording.mIntervals.Length();
+
−    mRecording.mIntervals[i] = static_cast<float>((now - mRecording.mLastFrameTime)
+
−                                                  .ToMilliseconds());
+
−    mRecording.mNextIndex++;
+
−    mRecording.mLastFrameTime = now;
+
−
+
−    if (mRecording.mNextIndex > (mRecording.mLatestStartIndex + mRecording.mIntervals.Length())) {
+
−      // We've just overwritten the most recent recording start -> pause.
+
−      mRecording.mIsPaused = true;
+
−    }
+
−  }
+
−}
+
−
+
−void
+
−LayerManager::StopFrameTimeRecording(uint32_t         aStartIndex,
+
−                                     nsTArray<float>& aFrameIntervals)
+
−{
+
−  uint32_t bufferSize = mRecording.mIntervals.Length();
+
−  uint32_t length = mRecording.mNextIndex - aStartIndex;
+
−  if (mRecording.mIsPaused || length > bufferSize || aStartIndex < mRecording.mCurrentRunStartIndex) {
+
−    // aStartIndex is too old. Also if aStartIndex was issued before mRecordingNextIndex overflowed (uint32_t)
+
−    //   and stopped after the overflow (would happen once every 828 days of constant 60fps).
+
−    length = 0;
+
−  }
+
−
+
−  if (!length) {
+
−    aFrameIntervals.Clear();
+
−    return; // empty recording, return empty arrays.
+
−  }
+
−  // Set length in advance to avoid possibly repeated reallocations
+
−  aFrameIntervals.SetLength(length);
+
−
+
−  uint32_t cyclicPos = aStartIndex % bufferSize;
+
−  for (uint32_t i = 0; i < length; i++, cyclicPos++) {
+
−    if (cyclicPos == bufferSize) {
+
−      cyclicPos = 0;
+
−    }
+
−    aFrameIntervals[i] = mRecording.mIntervals[cyclicPos];
+
−  }
+
−}
+
−
+
−static void PrintInfo(std::stringstream& aStream, HostLayer* aLayerComposite);
+
−
+
−#ifdef MOZ_DUMP_PAINTING
+
−template <typename T>
+
−void WriteSnapshotToDumpFile_internal(T* aObj, DataSourceSurface* aSurf)
+
−{
+
−  nsCString string(aObj->Name());
+
−  string.Append('-');
+
−  string.AppendInt((uint64_t)aObj);
+
−  if (gfxUtils::sDumpPaintFile != stderr) {
+
−    fprintf_stderr(gfxUtils::sDumpPaintFile, R"(array["%s"]=")", string.BeginReading());
+
−  }
+
−  gfxUtils::DumpAsDataURI(aSurf, gfxUtils::sDumpPaintFile);
+
−  if (gfxUtils::sDumpPaintFile != stderr) {
+
−    fprintf_stderr(gfxUtils::sDumpPaintFile, R"(";)");
+
−  }
+
−}
+
−
+
−void WriteSnapshotToDumpFile(Layer* aLayer, DataSourceSurface* aSurf)
+
−{
+
−  WriteSnapshotToDumpFile_internal(aLayer, aSurf);
+
−}
+
−
+
−void WriteSnapshotToDumpFile(LayerManager* aManager, DataSourceSurface* aSurf)
+
−{
+
−  WriteSnapshotToDumpFile_internal(aManager, aSurf);
+
−}
+
−
+
−void WriteSnapshotToDumpFile(Compositor* aCompositor, DrawTarget* aTarget)
+
−{
+
−  RefPtr<SourceSurface> surf = aTarget->Snapshot();
+
−  RefPtr<DataSourceSurface> dSurf = surf->GetDataSurface();
+
−  WriteSnapshotToDumpFile_internal(aCompositor, dSurf);
+
−}
+
−#endif
+
−
+
−void
+
−Layer::Dump(std::stringstream& aStream, const char* aPrefix,
+
−            bool aDumpHtml, bool aSorted, const Maybe<gfx::Polygon>& aGeometry)
+
−{
+
−#ifdef MOZ_DUMP_PAINTING
+
−  bool dumpCompositorTexture = gfxEnv::DumpCompositorTextures() && AsHostLayer() &&
+
−                               AsHostLayer()->GetCompositableHost();
+
−  bool dumpClientTexture = gfxEnv::DumpPaint() && AsShadowableLayer() &&
+
−                           AsShadowableLayer()->GetCompositableClient();
+
−  nsCString layerId(Name());
+
−  layerId.Append('-');
+
−  layerId.AppendInt((uint64_t)this);
+
−#endif
+
−  if (aDumpHtml) {
+
−    aStream << nsPrintfCString(R"(<li><a id="%p" )", this).get();
+
−#ifdef MOZ_DUMP_PAINTING
+
−    if (dumpCompositorTexture || dumpClientTexture) {
+
−      aStream << nsPrintfCString(R"lit(href="javascript:ViewImage('%s')")lit", layerId.BeginReading()).get();
+
−    }
+
−#endif
+
−    aStream << ">";
+
−  }
+
−  DumpSelf(aStream, aPrefix, aGeometry);
+
−
+
−#ifdef MOZ_DUMP_PAINTING
+
−  if (dumpCompositorTexture) {
+
−    AsHostLayer()->GetCompositableHost()->Dump(aStream, aPrefix, aDumpHtml);
+
−  } else if (dumpClientTexture) {
+
−    if (aDumpHtml) {
+
−      aStream << nsPrintfCString(R"(<script>array["%s"]=")", layerId.BeginReading()).get();
+
−    }
+
−    AsShadowableLayer()->GetCompositableClient()->Dump(aStream, aPrefix,
+
−        aDumpHtml, TextureDumpMode::DoNotCompress);
+
−    if (aDumpHtml) {
+
−      aStream << R"(";</script>)";
+
−    }
+
−  }
+
−#endif
+
−
+
−  if (aDumpHtml) {
+
−    aStream << "</a>";
+
−#ifdef MOZ_DUMP_PAINTING
+
−    if (dumpClientTexture) {
+
−      aStream << nsPrintfCString("<br><img id=\"%s\">\n", layerId.BeginReading()).get();
+
−    }
+
−#endif
+
−  }
+
−
+
−  if (Layer* mask = GetMaskLayer()) {
+
−    aStream << nsPrintfCString("%s  Mask layer:\n", aPrefix).get();
+
−    nsAutoCString pfx(aPrefix);
+
−    pfx += "    ";
+
−    mask->Dump(aStream, pfx.get(), aDumpHtml);
+
−  }
+
−
+
−  for (size_t i = 0; i < GetAncestorMaskLayerCount(); i++) {
+
−    aStream << nsPrintfCString("%s  Ancestor mask layer %d:\n", aPrefix, uint32_t(i)).get();
+
−    nsAutoCString pfx(aPrefix);
+
−    pfx += "    ";
+
−    GetAncestorMaskLayerAt(i)->Dump(aStream, pfx.get(), aDumpHtml);
+
−  }
+
−
+
−#ifdef MOZ_DUMP_PAINTING
+
−  for (size_t i = 0; i < mExtraDumpInfo.Length(); i++) {
+
−    const nsCString& str = mExtraDumpInfo[i];
+
−    aStream << aPrefix << "  Info:\n" << str.get();
+
−  }
+
−#endif
+
−
+
−  if (ContainerLayer* container = AsContainerLayer()) {
+
−    nsTArray<LayerPolygon> children;
+
−    if (aSorted) {
+
−      children =
+
−        container->SortChildrenBy3DZOrder(ContainerLayer::SortMode::WITH_GEOMETRY);
+
−    } else {
+
−      for (Layer* l = container->GetFirstChild(); l; l = l->GetNextSibling()) {
+
−        children.AppendElement(LayerPolygon(l));
+
−      }
+
−    }
+
−    nsAutoCString pfx(aPrefix);
+
−    pfx += "  ";
+
−    if (aDumpHtml) {
+
−      aStream << "<ul>";
+
−    }
+
−
+
−    for (LayerPolygon& child : children) {
+
−      child.layer->Dump(aStream, pfx.get(), aDumpHtml, aSorted, child.geometry);
+
−    }
+
−
+
−    if (aDumpHtml) {
+
−      aStream << "</ul>";
+
−    }
+
−  }
+
−
+
−  if (aDumpHtml) {
+
−    aStream << "</li>";
+
−  }
+
−}
+
−
+
−static void
+
−DumpGeometry(std::stringstream& aStream, const Maybe<gfx::Polygon>& aGeometry)
+
−{
+
−  aStream << " [geometry=[";
+
−
+
−  const nsTArray<gfx::Point4D>& points = aGeometry->GetPoints();
+
−  for (size_t i = 0; i < points.Length(); ++i) {
+
−    const gfx::IntPoint point = TruncatedToInt(points[i].As2DPoint());
+
−    const char* sfx = (i != points.Length() - 1) ? "," : "";
+
−    AppendToString(aStream, point, "", sfx);
+
−  }
+
−
+
−  aStream << "]]";
+
−}
+
−
+
−void
+
−Layer::DumpSelf(std::stringstream& aStream, const char* aPrefix,
+
−                const Maybe<gfx::Polygon>& aGeometry)
+
−{
+
−  PrintInfo(aStream, aPrefix);
+
−
+
−  if (aGeometry) {
+
−    DumpGeometry(aStream, aGeometry);
+
−  }
+
−
+
−  aStream << "\n";
+
−}
+
−
+
−void
+
−Layer::Dump(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  DumpPacket(aPacket, aParent);
+
−
+
−  if (Layer* kid = GetFirstChild()) {
+
−    kid->Dump(aPacket, this);
+
−  }
+
−
+
−  if (Layer* next = GetNextSibling()) {
+
−    next->Dump(aPacket, aParent);
+
−  }
+
−}
+
−
+
−void
+
−Layer::SetDisplayListLog(const char* log)
+
−{
+
−  if (gfxUtils::DumpDisplayList()) {
+
−    mDisplayListLog = log;
+
−  }
+
−}
+
−
+
−void
+
−Layer::GetDisplayListLog(nsCString& log)
+
−{
+
−  log.SetLength(0);
+
−
+
−  if (gfxUtils::DumpDisplayList()) {
+
−    // This function returns a plain text string which consists of two things
+
−    //   1. DisplayList log.
+
−    //   2. Memory address of this layer.
+
−    // We know the target layer of each display item by information in #1.
+
−    // Here is an example of a Text display item line log in #1
+
−    //   Text p=0xa9850c00 f=0x0xaa405b00(.....
+
−    // f keeps the address of the target client layer of a display item.
+
−    // For LayerScope, display-item-to-client-layer mapping is not enough since
+
−    // LayerScope, which lives in the chrome process, knows only composite layers.
+
−    // As so, we need display-item-to-client-layer-to-layer-composite
+
−    // mapping. That's the reason we insert #2 into the log
+
−    log.AppendPrintf("0x%p\n%s",(void*) this, mDisplayListLog.get());
+
−  }
+
−}
+
−
+
−void
+
−Layer::Log(const char* aPrefix)
+
−{
+
−  if (!IsLogEnabled())
+
−    return;
+
−
+
−  LogSelf(aPrefix);
+
−
+
−  if (Layer* kid = GetFirstChild()) {
+
−    nsAutoCString pfx(aPrefix);
+
−    pfx += "  ";
+
−    kid->Log(pfx.get());
+
−  }
+
−
+
−  if (Layer* next = GetNextSibling())
+
−    next->Log(aPrefix);
+
−}
+
−
+
−void
+
−Layer::LogSelf(const char* aPrefix)
+
−{
+
−  if (!IsLogEnabled())
+
−    return;
+
−
+
−  std::stringstream ss;
+
−  PrintInfo(ss, aPrefix);
+
−  MOZ_LAYERS_LOG(("%s", ss.str().c_str()));
+
−
+
−  if (mMaskLayer) {
+
−    nsAutoCString pfx(aPrefix);
+
−    pfx += R"(   \ MaskLayer )";
+
−    mMaskLayer->LogSelf(pfx.get());
+
−  }
+
−}
+
−
+
−void
+
−Layer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  aStream << aPrefix;
+
−  aStream << nsPrintfCString("%s%s (0x%p)", mManager->Name(), Name(), this).get();
+
−
+
−  layers::PrintInfo(aStream, AsHostLayer());
+
−
+
−  if (mClipRect) {
+
−    AppendToString(aStream, *mClipRect, " [clip=", "]");
+
−  }
+
−  if (mSimpleAttrs.ScrolledClip()) {
+
−    AppendToString(aStream, mSimpleAttrs.ScrolledClip()->GetClipRect(), " [scrolled-clip=", "]");
+
−    if (const Maybe<size_t>& ix = mSimpleAttrs.ScrolledClip()->GetMaskLayerIndex()) {
+
−      AppendToString(aStream, ix.value(), " [scrolled-mask=", "]");
+
−    }
+
−  }
+
−  if (1.0 != mSimpleAttrs.PostXScale() || 1.0 != mSimpleAttrs.PostYScale()) {
+
−    aStream << nsPrintfCString(" [postScale=%g, %g]", mSimpleAttrs.PostXScale(), mSimpleAttrs.PostYScale()).get();
+
−  }
+
−  if (!GetBaseTransform().IsIdentity()) {
+
−    AppendToString(aStream, GetBaseTransform(), " [transform=", "]");
+
−  }
+
−  if (!GetEffectiveTransform().IsIdentity()) {
+
−    AppendToString(aStream, GetEffectiveTransform(), " [effective-transform=", "]");
+
−  }
+
−  if (GetTransformIsPerspective()) {
+
−    aStream << " [perspective]";
+
−  }
+
−  if (!mVisibleRegion.IsEmpty()) {
+
−    AppendToString(aStream, mVisibleRegion.ToUnknownRegion(), " [visible=", "]");
+
−  } else {
+
−    aStream << " [not visible]";
+
−  }
+
−  if (!mEventRegions.IsEmpty()) {
+
−    AppendToString(aStream, mEventRegions, " ", "");
+
−  }
+
−  if (1.0 != GetOpacity()) {
+
−    aStream << nsPrintfCString(" [opacity=%g]", GetOpacity()).get();
+
−  }
+
−  if (IsOpaque()) {
+
−    aStream << " [opaqueContent]";
+
−  }
+
−  if (GetContentFlags() & CONTENT_COMPONENT_ALPHA) {
+
−    aStream << " [componentAlpha]";
+
−  }
+
−  if (GetContentFlags() & CONTENT_BACKFACE_HIDDEN) {
+
−    aStream << " [backfaceHidden]";
+
−  }
+
−  if (Extend3DContext()) {
+
−    aStream << " [extend3DContext]";
+
−  }
+
−  if (Combines3DTransformWithAncestors()) {
+
−    aStream << " [combines3DTransformWithAncestors]";
+
−  }
+
−  if (Is3DContextLeaf()) {
+
−    aStream << " [is3DContextLeaf]";
+
−  }
+
−  if (IsScrollbarContainer()) {
+
−    aStream << " [scrollbar]";
+
−  }
+
−  ScrollDirection thumbDirection = GetScrollThumbData().mDirection;
+
−  if (thumbDirection == ScrollDirection::VERTICAL) {
+
−    aStream << nsPrintfCString(" [vscrollbar=%" PRIu64 "]", GetScrollbarTargetContainerId()).get();
+
−  }
+
−  if (thumbDirection == ScrollDirection::HORIZONTAL) {
+
−    aStream << nsPrintfCString(" [hscrollbar=%" PRIu64 "]", GetScrollbarTargetContainerId()).get();
+
−  }
+
−  if (GetIsFixedPosition()) {
+
−    LayerPoint anchor = GetFixedPositionAnchor();
+
−    aStream << nsPrintfCString(" [isFixedPosition scrollId=%" PRIu64 " sides=0x%x anchor=%s]",
+
−                     GetFixedPositionScrollContainerId(),
+
−                     GetFixedPositionSides(),
+
−                     ToString(anchor).c_str()).get();
+
−  }
+
−  if (GetIsStickyPosition()) {
+
−    aStream << nsPrintfCString(" [isStickyPosition scrollId=%" PRIu64 " outer=(%.3f,%.3f)-(%.3f,%.3f) "
+
−                     "inner=(%.3f,%.3f)-(%.3f,%.3f)]",
+
−                     GetStickyScrollContainerId(),
+
−                     GetStickyScrollRangeOuter().x,
+
−                     GetStickyScrollRangeOuter().y,
+
−                     GetStickyScrollRangeOuter().XMost(),
+
−                     GetStickyScrollRangeOuter().YMost(),
+
−                     GetStickyScrollRangeInner().x,
+
−                     GetStickyScrollRangeInner().y,
+
−                     GetStickyScrollRangeInner().XMost(),
+
−                     GetStickyScrollRangeInner().YMost()).get();
+
−  }
+
−  if (mMaskLayer) {
+
−    aStream << nsPrintfCString(" [mMaskLayer=%p]", mMaskLayer.get()).get();
+
−  }
+
−  for (uint32_t i = 0; i < mScrollMetadata.Length(); i++) {
+
−    if (!mScrollMetadata[i].IsDefault()) {
+
−      aStream << nsPrintfCString(" [metrics%d=", i).get();
+
−      AppendToString(aStream, mScrollMetadata[i], "", "]");
+
−    }
+
−  }
+
−  if (!mAnimations.IsEmpty()) {
+
−    aStream << nsPrintfCString(" [%d animations with id=%" PRIu64 " ]",
+
−                               (int) mAnimations.Length(),
+
−                               mCompositorAnimationsId).get();
+
−  }
+
−}
+
−
+
−// The static helper function sets the transform matrix into the packet
+
−static void
+
−DumpTransform(layerscope::LayersPacket::Layer::Matrix* aLayerMatrix, const Matrix4x4& aMatrix)
+
−{
+
−  aLayerMatrix->set_is2d(aMatrix.Is2D());
+
−  if (aMatrix.Is2D()) {
+
−    Matrix m = aMatrix.As2D();
+
−    aLayerMatrix->set_isid(m.IsIdentity());
+
−    if (!m.IsIdentity()) {
+
−      aLayerMatrix->add_m(m._11); aLayerMatrix->add_m(m._12);
+
−      aLayerMatrix->add_m(m._21); aLayerMatrix->add_m(m._22);
+
−      aLayerMatrix->add_m(m._31); aLayerMatrix->add_m(m._32);
+
−    }
+
−  } else {
+
−    aLayerMatrix->add_m(aMatrix._11); aLayerMatrix->add_m(aMatrix._12);
+
−    aLayerMatrix->add_m(aMatrix._13); aLayerMatrix->add_m(aMatrix._14);
+
−    aLayerMatrix->add_m(aMatrix._21); aLayerMatrix->add_m(aMatrix._22);
+
−    aLayerMatrix->add_m(aMatrix._23); aLayerMatrix->add_m(aMatrix._24);
+
−    aLayerMatrix->add_m(aMatrix._31); aLayerMatrix->add_m(aMatrix._32);
+
−    aLayerMatrix->add_m(aMatrix._33); aLayerMatrix->add_m(aMatrix._34);
+
−    aLayerMatrix->add_m(aMatrix._41); aLayerMatrix->add_m(aMatrix._42);
+
−    aLayerMatrix->add_m(aMatrix._43); aLayerMatrix->add_m(aMatrix._44);
+
−  }
+
−}
+
−
+
−// The static helper function sets the IntRect into the packet
+
−template <typename T, typename Sub, typename Point, typename SizeT, typename MarginT>
+
−static void
+
−DumpRect(layerscope::LayersPacket::Layer::Rect* aLayerRect,
+
−         const BaseRect<T, Sub, Point, SizeT, MarginT>& aRect)
+
−{
+
−  aLayerRect->set_x(aRect.x);
+
−  aLayerRect->set_y(aRect.y);
+
−  aLayerRect->set_w(aRect.width);
+
−  aLayerRect->set_h(aRect.height);
+
−}
+
−
+
−// The static helper function sets the nsIntRegion into the packet
+
−static void
+
−DumpRegion(layerscope::LayersPacket::Layer::Region* aLayerRegion, const nsIntRegion& aRegion)
+
−{
+
−  for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
+
−    DumpRect(aLayerRegion->add_r(), iter.Get());
+
−  }
+
−}
+
−
+
−void
+
−Layer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  // Add a new layer (UnknownLayer)
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->add_layer();
+
−  // Basic information
+
−  layer->set_type(LayersPacket::Layer::UnknownLayer);
+
−  layer->set_ptr(reinterpret_cast<uint64_t>(this));
+
−  layer->set_parentptr(reinterpret_cast<uint64_t>(aParent));
+
−  // Shadow
+
−  if (HostLayer* lc = AsHostLayer()) {
+
−    LayersPacket::Layer::Shadow* s = layer->mutable_shadow();
+
−    if (const Maybe<ParentLayerIntRect>& clipRect = lc->GetShadowClipRect()) {
+
−      DumpRect(s->mutable_clip(), *clipRect);
+
−    }
+
−    if (!lc->GetShadowBaseTransform().IsIdentity()) {
+
−      DumpTransform(s->mutable_transform(), lc->GetShadowBaseTransform());
+
−    }
+
−    if (!lc->GetShadowVisibleRegion().IsEmpty()) {
+
−      DumpRegion(s->mutable_vregion(), lc->GetShadowVisibleRegion().ToUnknownRegion());
+
−    }
+
−  }
+
−  // Clip
+
−  if (mClipRect) {
+
−    DumpRect(layer->mutable_clip(), *mClipRect);
+
−  }
+
−  // Transform
+
−  if (!GetBaseTransform().IsIdentity()) {
+
−    DumpTransform(layer->mutable_transform(), GetBaseTransform());
+
−  }
+
−  // Visible region
+
−  if (!mVisibleRegion.ToUnknownRegion().IsEmpty()) {
+
−    DumpRegion(layer->mutable_vregion(), mVisibleRegion.ToUnknownRegion());
+
−  }
+
−  // EventRegions
+
−  if (!mEventRegions.IsEmpty()) {
+
−    const EventRegions &e = mEventRegions;
+
−    if (!e.mHitRegion.IsEmpty()) {
+
−      DumpRegion(layer->mutable_hitregion(), e.mHitRegion);
+
−    }
+
−    if (!e.mDispatchToContentHitRegion.IsEmpty()) {
+
−      DumpRegion(layer->mutable_dispatchregion(), e.mDispatchToContentHitRegion);
+
−    }
+
−    if (!e.mNoActionRegion.IsEmpty()) {
+
−      DumpRegion(layer->mutable_noactionregion(), e.mNoActionRegion);
+
−    }
+
−    if (!e.mHorizontalPanRegion.IsEmpty()) {
+
−      DumpRegion(layer->mutable_hpanregion(), e.mHorizontalPanRegion);
+
−    }
+
−    if (!e.mVerticalPanRegion.IsEmpty()) {
+
−      DumpRegion(layer->mutable_vpanregion(), e.mVerticalPanRegion);
+
−    }
+
−  }
+
−  // Opacity
+
−  layer->set_opacity(GetOpacity());
+
−  // Content opaque
+
−  layer->set_copaque(static_cast<bool>(GetContentFlags() & CONTENT_OPAQUE));
+
−  // Component alpha
+
−  layer->set_calpha(static_cast<bool>(GetContentFlags() & CONTENT_COMPONENT_ALPHA));
+
−  // Vertical or horizontal bar
+
−  ScrollDirection thumbDirection = GetScrollThumbData().mDirection;
+
−  if (thumbDirection != ScrollDirection::NONE) {
+
−    layer->set_direct(thumbDirection == ScrollDirection::VERTICAL ?
+
−                      LayersPacket::Layer::VERTICAL :
+
−                      LayersPacket::Layer::HORIZONTAL);
+
−    layer->set_barid(GetScrollbarTargetContainerId());
+
−  }
+
−
+
−  // Mask layer
+
−  if (mMaskLayer) {
+
−    layer->set_mask(reinterpret_cast<uint64_t>(mMaskLayer.get()));
+
−  }
+
−
+
−  // DisplayList log.
+
−  if (mDisplayListLog.Length() > 0) {
+
−    layer->set_displaylistloglength(mDisplayListLog.Length());
+
−    auto compressedData =
+
−      MakeUnique<char[]>(LZ4::maxCompressedSize(mDisplayListLog.Length()));
+
−    int compressedSize = LZ4::compress((char*)mDisplayListLog.get(),
+
−                                       mDisplayListLog.Length(),
+
−                                       compressedData.get());
+
−    layer->set_displaylistlog(compressedData.get(), compressedSize);
+
−  }
+
−}
+
−
+
−bool
+
−Layer::IsBackfaceHidden()
+
−{
+
−  if (GetContentFlags() & CONTENT_BACKFACE_HIDDEN) {
+
−    Layer* container = AsContainerLayer() ? this : GetParent();
+
−    if (container) {
+
−      // The effective transform can include non-preserve-3d parent
+
−      // transforms, since we don't always require an intermediate.
+
−      if (container->Extend3DContext() || container->Is3DContextLeaf()) {
+
−        return container->GetEffectiveTransform().IsBackfaceVisible();
+
−      }
+
−      return container->GetBaseTransform().IsBackfaceVisible();
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−UniquePtr<LayerUserData>
+
−Layer::RemoveUserData(void* aKey)
+
−{
+
−  UniquePtr<LayerUserData> d(static_cast<LayerUserData*>(mUserData.Remove(static_cast<gfx::UserDataKey*>(aKey))));
+
−  return d;
+
−}
+
−
+
−void
+
−Layer::SetManager(LayerManager* aManager, HostLayer* aSelf)
+
−{
+
−  // No one should be calling this for weird reasons.
+
−  MOZ_ASSERT(aSelf);
+
−  MOZ_ASSERT(aSelf->GetLayer() == this);
+
−  mManager = aManager;
+
−}
+
−
+
−void
+
−PaintedLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  nsIntRegion validRegion = GetValidRegion();
+
−  if (!validRegion.IsEmpty()) {
+
−    AppendToString(aStream, validRegion, " [valid=", "]");
+
−  }
+
−}
+
−
+
−void
+
−PaintedLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::PaintedLayer);
+
−  nsIntRegion validRegion = GetValidRegion();
+
−  if (!validRegion.IsEmpty()) {
+
−    DumpRegion(layer->mutable_valid(), validRegion);
+
−  }
+
−}
+
−
+
−void
+
−ContainerLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  if (UseIntermediateSurface()) {
+
−    aStream << " [usesTmpSurf]";
+
−  }
+
−  if (1.0 != mPreXScale || 1.0 != mPreYScale) {
+
−    aStream << nsPrintfCString(" [preScale=%g, %g]", mPreXScale, mPreYScale).get();
+
−  }
+
−  if (mScaleToResolution) {
+
−    aStream << nsPrintfCString(" [presShellResolution=%g]", mPresShellResolution).get();
+
−  }
+
−  if (mEventRegionsOverride & EventRegionsOverride::ForceDispatchToContent) {
+
−    aStream << " [force-dtc]";
+
−  }
+
−  if (mEventRegionsOverride & EventRegionsOverride::ForceEmptyHitRegion) {
+
−    aStream << " [force-ehr]";
+
−  }
+
−}
+
−
+
−void
+
−ContainerLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::ContainerLayer);
+
−}
+
−
+
−void
+
−DisplayItemLayer::EndTransaction() {
+
−  mItem = nullptr;
+
−  mBuilder = nullptr;
+
−}
+
−
+
−void
+
−DisplayItemLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  const char* type = "TYPE_UNKNOWN";
+
−  if (mItem) {
+
−    type = mItem->Name();
+
−  }
+
−
+
−  aStream << " [itype type=" << type << "]";
+
−}
+
−
+
−void
+
−DisplayItemLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::DisplayItemLayer);
+
−}
+
−
+
−void
+
−ColorLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  AppendToString(aStream, mColor, " [color=", "]");
+
−  AppendToString(aStream, mBounds, " [bounds=", "]");
+
−}
+
−
+
−void
+
−ColorLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::ColorLayer);
+
−  layer->set_color(mColor.ToABGR());
+
−}
+
−
+
−void
+
−TextLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  AppendToString(aStream, mBounds, " [bounds=", "]");
+
−}
+
−
+
−void
+
−TextLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::TextLayer);
+
−}
+
−
+
−void
+
−BorderLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−}
+
−
+
−void
+
−BorderLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−}
+
−
+
−CanvasLayer::CanvasLayer(LayerManager* aManager, void* aImplData)
+
−  : Layer(aManager, aImplData)
+
−  , mPreTransCallback(nullptr)
+
−  , mPreTransCallbackData(nullptr)
+
−  , mPostTransCallback(nullptr)
+
−  , mPostTransCallbackData(nullptr)
+
−  , mSamplingFilter(gfx::SamplingFilter::GOOD)
+
−  , mDirty(false)
+
−{}
+
−
+
−CanvasLayer::~CanvasLayer() = default;
+
−
+
−void
+
−CanvasLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  if (mSamplingFilter != SamplingFilter::GOOD) {
+
−    AppendToString(aStream, mSamplingFilter, " [filter=", "]");
+
−  }
+
−}
+
−
+
−// This help function is used to assign the correct enum value
+
−// to the packet
+
−static void
+
−DumpFilter(layerscope::LayersPacket::Layer* aLayer,
+
−           const SamplingFilter& aSamplingFilter)
+
−{
+
−  using namespace layerscope;
+
−  switch (aSamplingFilter) {
+
−    case SamplingFilter::GOOD:
+
−      aLayer->set_filter(LayersPacket::Layer::FILTER_GOOD);
+
−      break;
+
−    case SamplingFilter::LINEAR:
+
−      aLayer->set_filter(LayersPacket::Layer::FILTER_LINEAR);
+
−      break;
+
−    case SamplingFilter::POINT:
+
−      aLayer->set_filter(LayersPacket::Layer::FILTER_POINT);
+
−      break;
+
−    default:
+
−      // ignore it
+
−      break;
+
−  }
+
−}
+
−
+
−void
+
−CanvasLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::CanvasLayer);
+
−  DumpFilter(layer, mSamplingFilter);
+
−}
+
−
+
−void
+
−ImageLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  if (mSamplingFilter != SamplingFilter::GOOD) {
+
−    AppendToString(aStream, mSamplingFilter, " [filter=", "]");
+
−  }
+
−}
+
−
+
−void
+
−ImageLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::ImageLayer);
+
−  DumpFilter(layer, mSamplingFilter);
+
−}
+
−
+
−void
+
−RefLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  ContainerLayer::PrintInfo(aStream, aPrefix);
+
−  if (0 != mId) {
+
−    AppendToString(aStream, mId, " [id=", "]");
+
−  }
+
−}
+
−
+
−void
+
−RefLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::RefLayer);
+
−  layer->set_refid(mId);
+
−}
+
−
+
−void
+
−ReadbackLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  Layer::PrintInfo(aStream, aPrefix);
+
−  AppendToString(aStream, mSize, " [size=", "]");
+
−  if (mBackgroundLayer) {
+
−    AppendToString(aStream, mBackgroundLayer, " [backgroundLayer=", "]");
+
−    AppendToString(aStream, mBackgroundLayerOffset, " [backgroundOffset=", "]");
+
−  } else if (mBackgroundColor.a == 1.f) {
+
−    AppendToString(aStream, mBackgroundColor, " [backgroundColor=", "]");
+
−  } else {
+
−    aStream << " [nobackground]";
+
−  }
+
−}
+
−
+
−void
+
−ReadbackLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
+
−{
+
−  Layer::DumpPacket(aPacket, aParent);
+
−  // Get this layer data
+
−  using namespace layerscope;
+
−  LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
+
−  layer->set_type(LayersPacket::Layer::ReadbackLayer);
+
−  LayersPacket::Layer::Size* size = layer->mutable_size();
+
−  size->set_w(mSize.width);
+
−  size->set_h(mSize.height);
+
−}
+
−
+
−//--------------------------------------------------
+
−// LayerManager
+
−
+
−void
+
−LayerManager::Dump(std::stringstream& aStream, const char* aPrefix,
+
−                   bool aDumpHtml, bool aSorted)
+
−{
+
−#ifdef MOZ_DUMP_PAINTING
+
−  if (aDumpHtml) {
+
−    aStream << "<ul><li>";
+
−  }
+
−#endif
+
−  DumpSelf(aStream, aPrefix, aSorted);
+
−
+
−  nsAutoCString pfx(aPrefix);
+
−  pfx += "  ";
+
−  if (!GetRoot()) {
+
−    aStream << nsPrintfCString("%s(null)", pfx.get()).get();
+
−    if (aDumpHtml) {
+
−      aStream << "</li></ul>";
+
−    }
+
−    return;
+
−  }
+
−
+
−  if (aDumpHtml) {
+
−    aStream << "<ul>";
+
−  }
+
−  GetRoot()->Dump(aStream, pfx.get(), aDumpHtml, aSorted);
+
−  if (aDumpHtml) {
+
−    aStream << "</ul></li></ul>";
+
−  }
+
−  aStream << "\n";
+
−}
+
−
+
−void
+
−LayerManager::DumpSelf(std::stringstream& aStream, const char* aPrefix, bool aSorted)
+
−{
+
−  PrintInfo(aStream, aPrefix);
+
−  aStream << " --- in " << (aSorted ? "3D-sorted rendering order" : "content order");
+
−  aStream << "\n";
+
−}
+
−
+
−void
+
−LayerManager::Dump(bool aSorted)
+
−{
+
−  std::stringstream ss;
+
−  Dump(ss, "", false, aSorted);
+
−  print_stderr(ss);
+
−}
+
−
+
−void
+
−LayerManager::Dump(layerscope::LayersPacket* aPacket)
+
−{
+
−  DumpPacket(aPacket);
+
−
+
−  if (GetRoot()) {
+
−    GetRoot()->Dump(aPacket, this);
+
−  }
+
−}
+
−
+
−void
+
−LayerManager::Log(const char* aPrefix)
+
−{
+
−  if (!IsLogEnabled())
+
−    return;
+
−
+
−  LogSelf(aPrefix);
+
−
+
−  nsAutoCString pfx(aPrefix);
+
−  pfx += "  ";
+
−  if (!GetRoot()) {
+
−    MOZ_LAYERS_LOG(("%s(null)", pfx.get()));
+
−    return;
+
−  }
+
−
+
−  GetRoot()->Log(pfx.get());
+
−}
+
−
+
−void
+
−LayerManager::LogSelf(const char* aPrefix)
+
−{
+
−  nsAutoCString str;
+
−  std::stringstream ss;
+
−  PrintInfo(ss, aPrefix);
+
−  MOZ_LAYERS_LOG(("%s", ss.str().c_str()));
+
−}
+
−
+
−void
+
−LayerManager::PrintInfo(std::stringstream& aStream, const char* aPrefix)
+
−{
+
−  aStream << aPrefix << nsPrintfCString("%sLayerManager (0x%p)", Name(), this).get();
+
−}
+
−
+
−void
+
−LayerManager::DumpPacket(layerscope::LayersPacket* aPacket)
+
−{
+
−  using namespace layerscope;
+
−  // Add a new layer data (LayerManager)
+
−  LayersPacket::Layer* layer = aPacket->add_layer();
+
−  layer->set_type(LayersPacket::Layer::LayerManager);
+
−  layer->set_ptr(reinterpret_cast<uint64_t>(this));
+
−  // Layer Tree Root
+
−  layer->set_parentptr(0);
+
−}
+
−
+
−void
+
−LayerManager::TrackDisplayItemLayer(RefPtr<DisplayItemLayer> aLayer)
+
−{
+
−  mDisplayItemLayers.AppendElement(aLayer);
+
−}
+
−
+
−void
+
−LayerManager::ClearDisplayItemLayers()
+
−{
+
−  for (uint32_t i = 0; i < mDisplayItemLayers.Length(); i++) {
+
−    mDisplayItemLayers[i]->EndTransaction();
+
−  }
+
−
+
−  mDisplayItemLayers.Clear();
+
−}
+
−
+
−/*static*/ bool
+
−LayerManager::IsLogEnabled()
+
−{
+
−  return MOZ_LOG_TEST(GetLog(), LogLevel::Debug);
+
−}
+
−
+
−void
+
−LayerManager::SetPendingScrollUpdateForNextTransaction(FrameMetrics::ViewID aScrollId,
+
−                                                       const ScrollUpdateInfo& aUpdateInfo)
+
−{
+
−  mPendingScrollUpdates[aScrollId] = aUpdateInfo;
+
−}
+
−
+
−Maybe<ScrollUpdateInfo>
+
−LayerManager::GetPendingScrollInfoUpdate(FrameMetrics::ViewID aScrollId)
+
−{
+
−  auto it = mPendingScrollUpdates.find(aScrollId);
+
−  if (it != mPendingScrollUpdates.end()) {
+
−    return Some(it->second);
+
−  }
+
−  return Nothing();
+
−}
+
−
+
−void
+
−LayerManager::ClearPendingScrollInfoUpdate()
+
−{
+
−  mPendingScrollUpdates.clear();
+
−}
+
−
+
−void
+
−PrintInfo(std::stringstream& aStream, HostLayer* aLayerComposite)
+
−{
+
−  if (!aLayerComposite) {
+
−    return;
+
−  }
+
−  if (const Maybe<ParentLayerIntRect>& clipRect = aLayerComposite->GetShadowClipRect()) {
+
−    AppendToString(aStream, *clipRect, " [shadow-clip=", "]");
+
−  }
+
−  if (!aLayerComposite->GetShadowBaseTransform().IsIdentity()) {
+
−    AppendToString(aStream, aLayerComposite->GetShadowBaseTransform(), " [shadow-transform=", "]");
+
−  }
+
−  if (!aLayerComposite->GetShadowVisibleRegion().IsEmpty()) {
+
−    AppendToString(aStream, aLayerComposite->GetShadowVisibleRegion().ToUnknownRegion(), " [shadow-visible=", "]");
+
−  }
+
−}
+
−
+
−void
+
−SetAntialiasingFlags(Layer* aLayer, DrawTarget* aTarget)
+
−{
+
−  bool permitSubpixelAA = !(aLayer->GetContentFlags() & Layer::CONTENT_DISABLE_SUBPIXEL_AA);
+
−  if (aTarget->IsCurrentGroupOpaque()) {
+
−    aTarget->SetPermitSubpixelAA(permitSubpixelAA);
+
−    return;
+
−  }
+
−
+
−  const IntRect& bounds = aLayer->GetVisibleRegion().ToUnknownRegion().GetBounds();
+
−  gfx::Rect transformedBounds = aTarget->GetTransform().TransformBounds(gfx::Rect(Float(bounds.x), Float(bounds.y),
+
−                                                                                  Float(bounds.width), Float(bounds.height)));
+
−  transformedBounds.RoundOut();
+
−  IntRect intTransformedBounds;
+
−  transformedBounds.ToIntRect(&intTransformedBounds);
+
−  permitSubpixelAA &= !(aLayer->GetContentFlags() & Layer::CONTENT_COMPONENT_ALPHA) ||
+
−                      aTarget->GetOpaqueRect().Contains(intTransformedBounds);
+
−  aTarget->SetPermitSubpixelAA(permitSubpixelAA);
+
−}
+
−
+
−IntRect
+
−ToOutsideIntRect(const gfxRect &aRect)
+
−{
+
−  return IntRect::RoundOut(aRect.x, aRect.y, aRect.width, aRect.height);
+
−}
+
−
+
−TextLayer::TextLayer(LayerManager* aManager, void* aImplData)
+
−  : Layer(aManager, aImplData)
+
−{}
+
−
+
−TextLayer::~TextLayer()
+
−{}
+
−
+
−void
+
−TextLayer::SetGlyphs(nsTArray<GlyphArray>&& aGlyphs)
+
−{
+
−  MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) Glyphs", this));
+
−  mGlyphs = Move(aGlyphs);
+
−  Mutated();
+
−}
+
−
+
−} // namespace layers
+
−} // namespace mozilla